From ddd310904d31268bec6e971a22f1bfdb80bb6b0f Mon Sep 17 00:00:00 2001
From: Pulumi Bot <30351955+pulumi-bot@users.noreply.github.com>
Date: Sat, 28 Oct 2023 00:58:10 -0700
Subject: [PATCH] Upgrade pulumi-terraform-bridge to v3.63.2 (#464)
This PR was generated via `$ upgrade-provider pulumi/pulumi-spotinst
--kind=bridge --pr-reviewers=t0yv0`.
---
- Upgrading pulumi-terraform-bridge from v3.63.1 to v3.63.2.
---
examples/go.mod | 4 +-
examples/go.sum | 8 +-
provider/go.mod | 6 +-
provider/go.sum | 12 +-
sdk/go.mod | 2 +-
sdk/go.sum | 4 +-
sdk/python/pulumi_spotinst/_inputs.py | 1434 +----
sdk/python/pulumi_spotinst/_utilities.py | 19 -
sdk/python/pulumi_spotinst/aws/_inputs.py | 5200 ++---------------
sdk/python/pulumi_spotinst/aws/account.py | 32 +-
sdk/python/pulumi_spotinst/aws/beanstalk.py | 178 +-
sdk/python/pulumi_spotinst/aws/credentials.py | 48 +-
sdk/python/pulumi_spotinst/aws/elastigroup.py | 1009 +---
.../pulumi_spotinst/aws/managed_instance.py | 551 +-
sdk/python/pulumi_spotinst/aws/mr_scalar.py | 725 +--
sdk/python/pulumi_spotinst/aws/ocean.py | 453 +-
.../aws/ocean_extended_resource_definition.py | 46 +-
.../pulumi_spotinst/aws/ocean_launch_spec.py | 368 +-
sdk/python/pulumi_spotinst/aws/outputs.py | 5200 ++---------------
sdk/python/pulumi_spotinst/aws/suspension.py | 48 +-
sdk/python/pulumi_spotinst/azure/_inputs.py | 1726 +-----
.../pulumi_spotinst/azure/elastigroup.py | 317 +-
sdk/python/pulumi_spotinst/azure/ocean.py | 264 +-
sdk/python/pulumi_spotinst/azure/ocean_np.py | 338 +-
.../azure/ocean_np_virtual_node_group.py | 255 +-
.../azure/ocean_virtual_node_group.py | 102 +-
sdk/python/pulumi_spotinst/azure/outputs.py | 1726 +-----
.../pulumi_spotinst/config/__init__.pyi | 2 +-
sdk/python/pulumi_spotinst/config/vars.py | 2 +-
.../pulumi_spotinst/data_integration.py | 49 +-
sdk/python/pulumi_spotinst/ecs/_inputs.py | 922 +--
sdk/python/pulumi_spotinst/ecs/ocean.py | 386 +-
.../pulumi_spotinst/ecs/ocean_launch_spec.py | 215 +-
sdk/python/pulumi_spotinst/ecs/outputs.py | 922 +--
.../pulumi_spotinst/elastigroup_azure_v3.py | 240 +-
sdk/python/pulumi_spotinst/gcp/_inputs.py | 710 +--
sdk/python/pulumi_spotinst/gcp/elastigroup.py | 428 +-
sdk/python/pulumi_spotinst/gcp/outputs.py | 710 +--
sdk/python/pulumi_spotinst/gke/_inputs.py | 1425 +----
sdk/python/pulumi_spotinst/gke/elastigroup.py | 378 +-
.../pulumi_spotinst/gke/ocean_import.py | 209 +-
.../pulumi_spotinst/gke/ocean_launch_spec.py | 266 +-
.../gke/ocean_launch_spec_import.py | 52 +-
sdk/python/pulumi_spotinst/gke/outputs.py | 1425 +----
sdk/python/pulumi_spotinst/health_check.py | 81 +-
sdk/python/pulumi_spotinst/multai/_inputs.py | 234 +-
sdk/python/pulumi_spotinst/multai/balancer.py | 73 +-
.../pulumi_spotinst/multai/deployment.py | 32 +-
sdk/python/pulumi_spotinst/multai/listener.py | 79 +-
sdk/python/pulumi_spotinst/multai/outputs.py | 234 +-
.../pulumi_spotinst/multai/routing_rule.py | 112 +-
sdk/python/pulumi_spotinst/multai/target.py | 96 +-
.../pulumi_spotinst/multai/target_set.py | 111 +-
.../pulumi_spotinst/organization/_inputs.py | 144 +-
.../pulumi_spotinst/organization/outputs.py | 144 +-
.../pulumi_spotinst/organization/policy.py | 54 +-
.../organization/programmatic_user.py | 68 +-
.../pulumi_spotinst/organization/user.py | 98 +-
.../organization/user_group.py | 60 +-
sdk/python/pulumi_spotinst/outputs.py | 1434 +----
sdk/python/pulumi_spotinst/provider.py | 29 +-
sdk/python/pulumi_spotinst/spark/_inputs.py | 185 +-
sdk/python/pulumi_spotinst/spark/ocean.py | 87 +-
.../spark/ocean_virtual_node_group.py | 52 +-
sdk/python/pulumi_spotinst/spark/outputs.py | 185 +-
.../pulumi_spotinst/stateful_node_azure.py | 477 +-
sdk/python/pulumi_spotinst/subscription.py | 80 +-
67 files changed, 4269 insertions(+), 28296 deletions(-)
diff --git a/examples/go.mod b/examples/go.mod
index 442b7feb..aad81bf9 100644
--- a/examples/go.mod
+++ b/examples/go.mod
@@ -2,7 +2,7 @@ module github.com/pulumi/pulumi-spotinst/examples/v3
go 1.21
-require github.com/pulumi/pulumi/pkg/v3 v3.90.1
+require github.com/pulumi/pulumi/pkg/v3 v3.91.1
require (
cloud.google.com/go v0.110.4 // indirect
@@ -135,7 +135,7 @@ require (
github.com/pkg/term v1.1.0 // indirect
github.com/pmezard/go-difflib v1.0.0 // indirect
github.com/pulumi/esc v0.5.6 // indirect
- github.com/pulumi/pulumi/sdk/v3 v3.90.1 // indirect
+ github.com/pulumi/pulumi/sdk/v3 v3.91.1 // indirect
github.com/rivo/uniseg v0.4.4 // indirect
github.com/rogpeppe/go-internal v1.11.0 // indirect
github.com/ryanuber/go-glob v1.0.0 // indirect
diff --git a/examples/go.sum b/examples/go.sum
index 350f37bf..525c6c32 100644
--- a/examples/go.sum
+++ b/examples/go.sum
@@ -1436,10 +1436,10 @@ github.com/prometheus/prometheus v0.37.0/go.mod h1:egARUgz+K93zwqsVIAneFlLZefyGO
github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU=
github.com/pulumi/esc v0.5.6 h1:4WV3X7OEVcChIwbSG+JxhZDdmq/q7lFPaSjHRYlPwmI=
github.com/pulumi/esc v0.5.6/go.mod h1:wpwNfVS5fV7Kd51j4dJ6FWYlKfxdqyppgp0gtkzqH04=
-github.com/pulumi/pulumi/pkg/v3 v3.90.1 h1:RFC/eqTbDfIvfeVQL8WaPmyQr1KzZhAGIIDGr9jj9y8=
-github.com/pulumi/pulumi/pkg/v3 v3.90.1/go.mod h1:J+WbfN30g3FfQifpLjQPI0UhPsC9ASEePLK8Nix06A8=
-github.com/pulumi/pulumi/sdk/v3 v3.90.1 h1:iT4t57N92WGhEQtg+KVDEmYzgfEyri39eihQzcNmtrM=
-github.com/pulumi/pulumi/sdk/v3 v3.90.1/go.mod h1:zYaQQibB2pYKy/uG4c4YkX7lQIBpZ0KsuMaq/3HsIBQ=
+github.com/pulumi/pulumi/pkg/v3 v3.91.1 h1:xHnyEwJO9we2zCiM9gHTkJxjZ6a6yi5vYCwWHCYRj9Y=
+github.com/pulumi/pulumi/pkg/v3 v3.91.1/go.mod h1:dzBQDJyCOEhtBVN5INA5/i9yG9DZlsStl/mAkrhs9II=
+github.com/pulumi/pulumi/sdk/v3 v3.91.1 h1:6I9GMmHv23X+G6hoduU1XE6hBWSNtB+zcb1MX17YvlA=
+github.com/pulumi/pulumi/sdk/v3 v3.91.1/go.mod h1:zYaQQibB2pYKy/uG4c4YkX7lQIBpZ0KsuMaq/3HsIBQ=
github.com/rakyll/embedmd v0.0.0-20171029212350-c8060a0752a2/go.mod h1:7jOTMgqac46PZcF54q6l2hkLEG8op93fZu61KmxWDV4=
github.com/rcrowley/go-metrics v0.0.0-20181016184325-3113b8401b8a/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4=
github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
diff --git a/provider/go.mod b/provider/go.mod
index ac9a4be2..c5cc061e 100644
--- a/provider/go.mod
+++ b/provider/go.mod
@@ -3,8 +3,8 @@ module github.com/pulumi/pulumi-spotinst/provider/v3
go 1.21
require (
- github.com/pulumi/pulumi-terraform-bridge/v3 v3.63.1
- github.com/pulumi/pulumi/sdk/v3 v3.90.1
+ github.com/pulumi/pulumi-terraform-bridge/v3 v3.63.2
+ github.com/pulumi/pulumi/sdk/v3 v3.91.1
github.com/spotinst/terraform-provider-spotinst v0.0.0
)
@@ -183,7 +183,7 @@ require (
github.com/pulumi/pulumi-java/pkg v0.9.8 // indirect
github.com/pulumi/pulumi-terraform-bridge/x/muxer v0.0.4 // indirect
github.com/pulumi/pulumi-yaml v1.2.2 // indirect
- github.com/pulumi/pulumi/pkg/v3 v3.90.1 // indirect
+ github.com/pulumi/pulumi/pkg/v3 v3.91.1 // indirect
github.com/pulumi/schema-tools v0.1.2 // indirect
github.com/pulumi/terraform-diff-reader v0.0.2 // indirect
github.com/rivo/uniseg v0.4.4 // indirect
diff --git a/provider/go.sum b/provider/go.sum
index 19b33e41..16817341 100644
--- a/provider/go.sum
+++ b/provider/go.sum
@@ -2192,16 +2192,16 @@ github.com/pulumi/pulumi-java/pkg v0.9.8 h1:c8mYsalnRXA2Ibgvv6scefOn6mW1Vb0UT0mc
github.com/pulumi/pulumi-java/pkg v0.9.8/go.mod h1:c6rSw/+q4O0IImgJ9axxoC6QesbPYWBaG5gimbHouUQ=
github.com/pulumi/pulumi-terraform-bridge/testing v0.0.1 h1:SCg1gjfY9N4yn8U8peIUYATifjoDABkyR7H9lmefsfc=
github.com/pulumi/pulumi-terraform-bridge/testing v0.0.1/go.mod h1:7OeUPH8rpt5ipyj9EFcnXpuzQ8SHL0dyqdfa8nOacdk=
-github.com/pulumi/pulumi-terraform-bridge/v3 v3.63.1 h1:hBgediyT2LdS5yfD5AMiCmBJ/TYP94Xxv6a4TcAfV0g=
-github.com/pulumi/pulumi-terraform-bridge/v3 v3.63.1/go.mod h1:6YVbDo019OeHkQWo9MnUbBy6cCgCQeoXZDjmR9SYmUA=
+github.com/pulumi/pulumi-terraform-bridge/v3 v3.63.2 h1:6JRJz3Wk7O9OhNFbxCrNvPVQAK+prBm6XBuSlIVqRnU=
+github.com/pulumi/pulumi-terraform-bridge/v3 v3.63.2/go.mod h1:ye7JUFqTNbBh6ohcr1KpyXNv+kYFYvZAIqXqts4Ialc=
github.com/pulumi/pulumi-terraform-bridge/x/muxer v0.0.4 h1:rIzMmtcVpPX8ynaz6/nW5AHNY63DiNfCohqmxWvMpM4=
github.com/pulumi/pulumi-terraform-bridge/x/muxer v0.0.4/go.mod h1:Kt8RIZWa/N8rW3+0g6NrqCBmF3o+HuIhFaZpssEkG6w=
github.com/pulumi/pulumi-yaml v1.2.2 h1:W6BeUBLhDrJ2GSU0em1AUVelG9PBI4ABY61DdhJOO3E=
github.com/pulumi/pulumi-yaml v1.2.2/go.mod h1:EgakC7b/4+VBNnlgM1RZIea2gUstV8s/7bdFJZt0P64=
-github.com/pulumi/pulumi/pkg/v3 v3.90.1 h1:RFC/eqTbDfIvfeVQL8WaPmyQr1KzZhAGIIDGr9jj9y8=
-github.com/pulumi/pulumi/pkg/v3 v3.90.1/go.mod h1:J+WbfN30g3FfQifpLjQPI0UhPsC9ASEePLK8Nix06A8=
-github.com/pulumi/pulumi/sdk/v3 v3.90.1 h1:iT4t57N92WGhEQtg+KVDEmYzgfEyri39eihQzcNmtrM=
-github.com/pulumi/pulumi/sdk/v3 v3.90.1/go.mod h1:zYaQQibB2pYKy/uG4c4YkX7lQIBpZ0KsuMaq/3HsIBQ=
+github.com/pulumi/pulumi/pkg/v3 v3.91.1 h1:xHnyEwJO9we2zCiM9gHTkJxjZ6a6yi5vYCwWHCYRj9Y=
+github.com/pulumi/pulumi/pkg/v3 v3.91.1/go.mod h1:dzBQDJyCOEhtBVN5INA5/i9yG9DZlsStl/mAkrhs9II=
+github.com/pulumi/pulumi/sdk/v3 v3.91.1 h1:6I9GMmHv23X+G6hoduU1XE6hBWSNtB+zcb1MX17YvlA=
+github.com/pulumi/pulumi/sdk/v3 v3.91.1/go.mod h1:zYaQQibB2pYKy/uG4c4YkX7lQIBpZ0KsuMaq/3HsIBQ=
github.com/pulumi/schema-tools v0.1.2 h1:Fd9xvUjgck4NA+7/jSk7InqCUT4Kj940+EcnbQKpfZo=
github.com/pulumi/schema-tools v0.1.2/go.mod h1:62lgj52Tzq11eqWTIaKd+EVyYAu5dEcDJxMhTjvMO/k=
github.com/pulumi/terraform-diff-reader v0.0.2 h1:kTE4nEXU3/SYXESvAIem+wyHMI3abqkI3OhJ0G04LLI=
diff --git a/sdk/go.mod b/sdk/go.mod
index 09276c37..18545875 100644
--- a/sdk/go.mod
+++ b/sdk/go.mod
@@ -4,7 +4,7 @@ go 1.21
require (
github.com/blang/semver v3.5.1+incompatible
- github.com/pulumi/pulumi/sdk/v3 v3.90.1
+ github.com/pulumi/pulumi/sdk/v3 v3.91.1
)
require (
diff --git a/sdk/go.sum b/sdk/go.sum
index 0da5bb30..eca3ea99 100644
--- a/sdk/go.sum
+++ b/sdk/go.sum
@@ -144,8 +144,8 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/pulumi/esc v0.5.6 h1:4WV3X7OEVcChIwbSG+JxhZDdmq/q7lFPaSjHRYlPwmI=
github.com/pulumi/esc v0.5.6/go.mod h1:wpwNfVS5fV7Kd51j4dJ6FWYlKfxdqyppgp0gtkzqH04=
-github.com/pulumi/pulumi/sdk/v3 v3.90.1 h1:iT4t57N92WGhEQtg+KVDEmYzgfEyri39eihQzcNmtrM=
-github.com/pulumi/pulumi/sdk/v3 v3.90.1/go.mod h1:zYaQQibB2pYKy/uG4c4YkX7lQIBpZ0KsuMaq/3HsIBQ=
+github.com/pulumi/pulumi/sdk/v3 v3.91.1 h1:6I9GMmHv23X+G6hoduU1XE6hBWSNtB+zcb1MX17YvlA=
+github.com/pulumi/pulumi/sdk/v3 v3.91.1/go.mod h1:zYaQQibB2pYKy/uG4c4YkX7lQIBpZ0KsuMaq/3HsIBQ=
github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
diff --git a/sdk/python/pulumi_spotinst/_inputs.py b/sdk/python/pulumi_spotinst/_inputs.py
index 43aadc0d..30340bb4 100644
--- a/sdk/python/pulumi_spotinst/_inputs.py
+++ b/sdk/python/pulumi_spotinst/_inputs.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from . import _utilities
__all__ = [
@@ -66,26 +66,9 @@ def __init__(__self__, *,
"""
:param pulumi.Input[str] subdir: The subdirectory in which your files will be stored within the bucket. Adds the prefix subdir/ to new objects' keys. Can't be null or contain '/'.
"""
- DataIntegrationS3Args._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- bucket_name=bucket_name,
- subdir=subdir,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- bucket_name: Optional[pulumi.Input[str]] = None,
- subdir: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if bucket_name is None and 'bucketName' in kwargs:
- bucket_name = kwargs['bucketName']
- if bucket_name is None:
- raise TypeError("Missing 'bucket_name' argument")
-
- _setter("bucket_name", bucket_name)
+ pulumi.set(__self__, "bucket_name", bucket_name)
if subdir is not None:
- _setter("subdir", subdir)
+ pulumi.set(__self__, "subdir", subdir)
@property
@pulumi.getter(name="bucketName")
@@ -114,23 +97,10 @@ class ElastigroupAzureV3ImageArgs:
def __init__(__self__, *,
customs: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupAzureV3ImageCustomArgs']]]] = None,
marketplaces: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupAzureV3ImageMarketplaceArgs']]]] = None):
- ElastigroupAzureV3ImageArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- customs=customs,
- marketplaces=marketplaces,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- customs: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupAzureV3ImageCustomArgs']]]] = None,
- marketplaces: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupAzureV3ImageMarketplaceArgs']]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if customs is not None:
- _setter("customs", customs)
+ pulumi.set(__self__, "customs", customs)
if marketplaces is not None:
- _setter("marketplaces", marketplaces)
+ pulumi.set(__self__, "marketplaces", marketplaces)
@property
@pulumi.getter
@@ -156,29 +126,8 @@ class ElastigroupAzureV3ImageCustomArgs:
def __init__(__self__, *,
image_name: pulumi.Input[str],
resource_group_name: pulumi.Input[str]):
- ElastigroupAzureV3ImageCustomArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- image_name=image_name,
- resource_group_name=resource_group_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- image_name: Optional[pulumi.Input[str]] = None,
- resource_group_name: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if image_name is None and 'imageName' in kwargs:
- image_name = kwargs['imageName']
- if image_name is None:
- raise TypeError("Missing 'image_name' argument")
- if resource_group_name is None and 'resourceGroupName' in kwargs:
- resource_group_name = kwargs['resourceGroupName']
- if resource_group_name is None:
- raise TypeError("Missing 'resource_group_name' argument")
-
- _setter("image_name", image_name)
- _setter("resource_group_name", resource_group_name)
+ pulumi.set(__self__, "image_name", image_name)
+ pulumi.set(__self__, "resource_group_name", resource_group_name)
@property
@pulumi.getter(name="imageName")
@@ -206,35 +155,10 @@ def __init__(__self__, *,
publisher: pulumi.Input[str],
sku: pulumi.Input[str],
version: pulumi.Input[str]):
- ElastigroupAzureV3ImageMarketplaceArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- offer=offer,
- publisher=publisher,
- sku=sku,
- version=version,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- offer: Optional[pulumi.Input[str]] = None,
- publisher: Optional[pulumi.Input[str]] = None,
- sku: Optional[pulumi.Input[str]] = None,
- version: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if offer is None:
- raise TypeError("Missing 'offer' argument")
- if publisher is None:
- raise TypeError("Missing 'publisher' argument")
- if sku is None:
- raise TypeError("Missing 'sku' argument")
- if version is None:
- raise TypeError("Missing 'version' argument")
-
- _setter("offer", offer)
- _setter("publisher", publisher)
- _setter("sku", sku)
- _setter("version", version)
+ pulumi.set(__self__, "offer", offer)
+ pulumi.set(__self__, "publisher", publisher)
+ pulumi.set(__self__, "sku", sku)
+ pulumi.set(__self__, "version", version)
@property
@pulumi.getter
@@ -279,32 +203,11 @@ def __init__(__self__, *,
user_name: pulumi.Input[str],
password: Optional[pulumi.Input[str]] = None,
ssh_public_key: Optional[pulumi.Input[str]] = None):
- ElastigroupAzureV3LoginArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- user_name=user_name,
- password=password,
- ssh_public_key=ssh_public_key,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- user_name: Optional[pulumi.Input[str]] = None,
- password: Optional[pulumi.Input[str]] = None,
- ssh_public_key: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if user_name is None and 'userName' in kwargs:
- user_name = kwargs['userName']
- if user_name is None:
- raise TypeError("Missing 'user_name' argument")
- if ssh_public_key is None and 'sshPublicKey' in kwargs:
- ssh_public_key = kwargs['sshPublicKey']
-
- _setter("user_name", user_name)
+ pulumi.set(__self__, "user_name", user_name)
if password is not None:
- _setter("password", password)
+ pulumi.set(__self__, "password", password)
if ssh_public_key is not None:
- _setter("ssh_public_key", ssh_public_key)
+ pulumi.set(__self__, "ssh_public_key", ssh_public_key)
@property
@pulumi.getter(name="userName")
@@ -339,27 +242,8 @@ class ElastigroupAzureV3ManagedServiceIdentityArgs:
def __init__(__self__, *,
name: pulumi.Input[str],
resource_group_name: pulumi.Input[str]):
- ElastigroupAzureV3ManagedServiceIdentityArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- resource_group_name=resource_group_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- resource_group_name: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
- if resource_group_name is None and 'resourceGroupName' in kwargs:
- resource_group_name = kwargs['resourceGroupName']
- if resource_group_name is None:
- raise TypeError("Missing 'resource_group_name' argument")
-
- _setter("name", name)
- _setter("resource_group_name", resource_group_name)
+ pulumi.set(__self__, "name", name)
+ pulumi.set(__self__, "resource_group_name", resource_group_name)
@property
@pulumi.getter
@@ -386,36 +270,9 @@ def __init__(__self__, *,
network_interfaces: pulumi.Input[Sequence[pulumi.Input['ElastigroupAzureV3NetworkNetworkInterfaceArgs']]],
resource_group_name: pulumi.Input[str],
virtual_network_name: pulumi.Input[str]):
- ElastigroupAzureV3NetworkArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- network_interfaces=network_interfaces,
- resource_group_name=resource_group_name,
- virtual_network_name=virtual_network_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- network_interfaces: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupAzureV3NetworkNetworkInterfaceArgs']]]] = None,
- resource_group_name: Optional[pulumi.Input[str]] = None,
- virtual_network_name: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if network_interfaces is None and 'networkInterfaces' in kwargs:
- network_interfaces = kwargs['networkInterfaces']
- if network_interfaces is None:
- raise TypeError("Missing 'network_interfaces' argument")
- if resource_group_name is None and 'resourceGroupName' in kwargs:
- resource_group_name = kwargs['resourceGroupName']
- if resource_group_name is None:
- raise TypeError("Missing 'resource_group_name' argument")
- if virtual_network_name is None and 'virtualNetworkName' in kwargs:
- virtual_network_name = kwargs['virtualNetworkName']
- if virtual_network_name is None:
- raise TypeError("Missing 'virtual_network_name' argument")
-
- _setter("network_interfaces", network_interfaces)
- _setter("resource_group_name", resource_group_name)
- _setter("virtual_network_name", virtual_network_name)
+ pulumi.set(__self__, "network_interfaces", network_interfaces)
+ pulumi.set(__self__, "resource_group_name", resource_group_name)
+ pulumi.set(__self__, "virtual_network_name", virtual_network_name)
@property
@pulumi.getter(name="networkInterfaces")
@@ -453,48 +310,13 @@ def __init__(__self__, *,
subnet_name: pulumi.Input[str],
additional_ip_configs: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupAzureV3NetworkNetworkInterfaceAdditionalIpConfigArgs']]]] = None,
application_security_groups: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupAzureV3NetworkNetworkInterfaceApplicationSecurityGroupArgs']]]] = None):
- ElastigroupAzureV3NetworkNetworkInterfaceArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- assign_public_ip=assign_public_ip,
- is_primary=is_primary,
- subnet_name=subnet_name,
- additional_ip_configs=additional_ip_configs,
- application_security_groups=application_security_groups,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- assign_public_ip: Optional[pulumi.Input[bool]] = None,
- is_primary: Optional[pulumi.Input[bool]] = None,
- subnet_name: Optional[pulumi.Input[str]] = None,
- additional_ip_configs: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupAzureV3NetworkNetworkInterfaceAdditionalIpConfigArgs']]]] = None,
- application_security_groups: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupAzureV3NetworkNetworkInterfaceApplicationSecurityGroupArgs']]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if assign_public_ip is None and 'assignPublicIp' in kwargs:
- assign_public_ip = kwargs['assignPublicIp']
- if assign_public_ip is None:
- raise TypeError("Missing 'assign_public_ip' argument")
- if is_primary is None and 'isPrimary' in kwargs:
- is_primary = kwargs['isPrimary']
- if is_primary is None:
- raise TypeError("Missing 'is_primary' argument")
- if subnet_name is None and 'subnetName' in kwargs:
- subnet_name = kwargs['subnetName']
- if subnet_name is None:
- raise TypeError("Missing 'subnet_name' argument")
- if additional_ip_configs is None and 'additionalIpConfigs' in kwargs:
- additional_ip_configs = kwargs['additionalIpConfigs']
- if application_security_groups is None and 'applicationSecurityGroups' in kwargs:
- application_security_groups = kwargs['applicationSecurityGroups']
-
- _setter("assign_public_ip", assign_public_ip)
- _setter("is_primary", is_primary)
- _setter("subnet_name", subnet_name)
+ pulumi.set(__self__, "assign_public_ip", assign_public_ip)
+ pulumi.set(__self__, "is_primary", is_primary)
+ pulumi.set(__self__, "subnet_name", subnet_name)
if additional_ip_configs is not None:
- _setter("additional_ip_configs", additional_ip_configs)
+ pulumi.set(__self__, "additional_ip_configs", additional_ip_configs)
if application_security_groups is not None:
- _setter("application_security_groups", application_security_groups)
+ pulumi.set(__self__, "application_security_groups", application_security_groups)
@property
@pulumi.getter(name="assignPublicIp")
@@ -547,26 +369,9 @@ class ElastigroupAzureV3NetworkNetworkInterfaceAdditionalIpConfigArgs:
def __init__(__self__, *,
name: pulumi.Input[str],
private_ip_version: Optional[pulumi.Input[str]] = None):
- ElastigroupAzureV3NetworkNetworkInterfaceAdditionalIpConfigArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- private_ip_version=private_ip_version,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- private_ip_version: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
- if private_ip_version is None and 'privateIpVersion' in kwargs:
- private_ip_version = kwargs['privateIpVersion']
-
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if private_ip_version is not None:
- _setter("private_ip_version", private_ip_version)
+ pulumi.set(__self__, "private_ip_version", private_ip_version)
@property
@pulumi.getter
@@ -592,27 +397,8 @@ class ElastigroupAzureV3NetworkNetworkInterfaceApplicationSecurityGroupArgs:
def __init__(__self__, *,
name: pulumi.Input[str],
resource_group_name: pulumi.Input[str]):
- ElastigroupAzureV3NetworkNetworkInterfaceApplicationSecurityGroupArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- resource_group_name=resource_group_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- resource_group_name: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
- if resource_group_name is None and 'resourceGroupName' in kwargs:
- resource_group_name = kwargs['resourceGroupName']
- if resource_group_name is None:
- raise TypeError("Missing 'resource_group_name' argument")
-
- _setter("name", name)
- _setter("resource_group_name", resource_group_name)
+ pulumi.set(__self__, "name", name)
+ pulumi.set(__self__, "resource_group_name", resource_group_name)
@property
@pulumi.getter
@@ -638,25 +424,8 @@ class ElastigroupAzureV3TagArgs:
def __init__(__self__, *,
key: pulumi.Input[str],
value: pulumi.Input[str]):
- ElastigroupAzureV3TagArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -698,60 +467,19 @@ def __init__(__self__, *,
:param pulumi.Input[str] endpoint: The destination for the request.
:param pulumi.Input[int] timeout: the amount of time (in seconds) to wait when receiving a response from the health check.
"""
- HealthCheckCheckArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- healthy=healthy,
- interval=interval,
- port=port,
- protocol=protocol,
- unhealthy=unhealthy,
- end_point=end_point,
- endpoint=endpoint,
- time_out=time_out,
- timeout=timeout,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- healthy: Optional[pulumi.Input[int]] = None,
- interval: Optional[pulumi.Input[int]] = None,
- port: Optional[pulumi.Input[int]] = None,
- protocol: Optional[pulumi.Input[str]] = None,
- unhealthy: Optional[pulumi.Input[int]] = None,
- end_point: Optional[pulumi.Input[str]] = None,
- endpoint: Optional[pulumi.Input[str]] = None,
- time_out: Optional[pulumi.Input[int]] = None,
- timeout: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if healthy is None:
- raise TypeError("Missing 'healthy' argument")
- if interval is None:
- raise TypeError("Missing 'interval' argument")
- if port is None:
- raise TypeError("Missing 'port' argument")
- if protocol is None:
- raise TypeError("Missing 'protocol' argument")
- if unhealthy is None:
- raise TypeError("Missing 'unhealthy' argument")
- if end_point is None and 'endPoint' in kwargs:
- end_point = kwargs['endPoint']
- if time_out is None and 'timeOut' in kwargs:
- time_out = kwargs['timeOut']
-
- _setter("healthy", healthy)
- _setter("interval", interval)
- _setter("port", port)
- _setter("protocol", protocol)
- _setter("unhealthy", unhealthy)
+ pulumi.set(__self__, "healthy", healthy)
+ pulumi.set(__self__, "interval", interval)
+ pulumi.set(__self__, "port", port)
+ pulumi.set(__self__, "protocol", protocol)
+ pulumi.set(__self__, "unhealthy", unhealthy)
if end_point is not None:
- _setter("end_point", end_point)
+ pulumi.set(__self__, "end_point", end_point)
if endpoint is not None:
- _setter("endpoint", endpoint)
+ pulumi.set(__self__, "endpoint", endpoint)
if time_out is not None:
- _setter("time_out", time_out)
+ pulumi.set(__self__, "time_out", time_out)
if timeout is not None:
- _setter("timeout", timeout)
+ pulumi.set(__self__, "timeout", timeout)
@property
@pulumi.getter
@@ -865,51 +593,14 @@ def __init__(__self__, *,
storage_account_type: pulumi.Input[str],
lun: Optional[pulumi.Input[int]] = None,
zone: Optional[pulumi.Input[str]] = None):
- StatefulNodeAzureAttachDataDiskArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- data_disk_name=data_disk_name,
- data_disk_resource_group_name=data_disk_resource_group_name,
- size_gb=size_gb,
- storage_account_type=storage_account_type,
- lun=lun,
- zone=zone,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- data_disk_name: Optional[pulumi.Input[str]] = None,
- data_disk_resource_group_name: Optional[pulumi.Input[str]] = None,
- size_gb: Optional[pulumi.Input[int]] = None,
- storage_account_type: Optional[pulumi.Input[str]] = None,
- lun: Optional[pulumi.Input[int]] = None,
- zone: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if data_disk_name is None and 'dataDiskName' in kwargs:
- data_disk_name = kwargs['dataDiskName']
- if data_disk_name is None:
- raise TypeError("Missing 'data_disk_name' argument")
- if data_disk_resource_group_name is None and 'dataDiskResourceGroupName' in kwargs:
- data_disk_resource_group_name = kwargs['dataDiskResourceGroupName']
- if data_disk_resource_group_name is None:
- raise TypeError("Missing 'data_disk_resource_group_name' argument")
- if size_gb is None and 'sizeGb' in kwargs:
- size_gb = kwargs['sizeGb']
- if size_gb is None:
- raise TypeError("Missing 'size_gb' argument")
- if storage_account_type is None and 'storageAccountType' in kwargs:
- storage_account_type = kwargs['storageAccountType']
- if storage_account_type is None:
- raise TypeError("Missing 'storage_account_type' argument")
-
- _setter("data_disk_name", data_disk_name)
- _setter("data_disk_resource_group_name", data_disk_resource_group_name)
- _setter("size_gb", size_gb)
- _setter("storage_account_type", storage_account_type)
+ pulumi.set(__self__, "data_disk_name", data_disk_name)
+ pulumi.set(__self__, "data_disk_resource_group_name", data_disk_resource_group_name)
+ pulumi.set(__self__, "size_gb", size_gb)
+ pulumi.set(__self__, "storage_account_type", storage_account_type)
if lun is not None:
- _setter("lun", lun)
+ pulumi.set(__self__, "lun", lun)
if zone is not None:
- _setter("zone", zone)
+ pulumi.set(__self__, "zone", zone)
@property
@pulumi.getter(name="dataDiskName")
@@ -972,31 +663,12 @@ def __init__(__self__, *,
is_enabled: Optional[pulumi.Input[bool]] = None,
storage_url: Optional[pulumi.Input[str]] = None,
type: Optional[pulumi.Input[str]] = None):
- StatefulNodeAzureBootDiagnosticArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- is_enabled=is_enabled,
- storage_url=storage_url,
- type=type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- is_enabled: Optional[pulumi.Input[bool]] = None,
- storage_url: Optional[pulumi.Input[str]] = None,
- type: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
- if storage_url is None and 'storageUrl' in kwargs:
- storage_url = kwargs['storageUrl']
-
if is_enabled is not None:
- _setter("is_enabled", is_enabled)
+ pulumi.set(__self__, "is_enabled", is_enabled)
if storage_url is not None:
- _setter("storage_url", storage_url)
+ pulumi.set(__self__, "storage_url", storage_url)
if type is not None:
- _setter("type", type)
+ pulumi.set(__self__, "type", type)
@property
@pulumi.getter(name="isEnabled")
@@ -1032,32 +704,9 @@ def __init__(__self__, *,
lun: pulumi.Input[int],
size_gb: pulumi.Input[int],
type: pulumi.Input[str]):
- StatefulNodeAzureDataDiskArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- lun=lun,
- size_gb=size_gb,
- type=type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- lun: Optional[pulumi.Input[int]] = None,
- size_gb: Optional[pulumi.Input[int]] = None,
- type: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if lun is None:
- raise TypeError("Missing 'lun' argument")
- if size_gb is None and 'sizeGb' in kwargs:
- size_gb = kwargs['sizeGb']
- if size_gb is None:
- raise TypeError("Missing 'size_gb' argument")
- if type is None:
- raise TypeError("Missing 'type' argument")
-
- _setter("lun", lun)
- _setter("size_gb", size_gb)
- _setter("type", type)
+ pulumi.set(__self__, "lun", lun)
+ pulumi.set(__self__, "size_gb", size_gb)
+ pulumi.set(__self__, "type", type)
@property
@pulumi.getter
@@ -1099,74 +748,19 @@ def __init__(__self__, *,
network_ttl_in_hours: Optional[pulumi.Input[int]] = None,
public_ip_ttl_in_hours: Optional[pulumi.Input[int]] = None,
snapshot_ttl_in_hours: Optional[pulumi.Input[int]] = None):
- StatefulNodeAzureDeleteArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- disk_should_deallocate=disk_should_deallocate,
- network_should_deallocate=network_should_deallocate,
- public_ip_should_deallocate=public_ip_should_deallocate,
- should_terminate_vm=should_terminate_vm,
- snapshot_should_deallocate=snapshot_should_deallocate,
- disk_ttl_in_hours=disk_ttl_in_hours,
- network_ttl_in_hours=network_ttl_in_hours,
- public_ip_ttl_in_hours=public_ip_ttl_in_hours,
- snapshot_ttl_in_hours=snapshot_ttl_in_hours,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- disk_should_deallocate: Optional[pulumi.Input[bool]] = None,
- network_should_deallocate: Optional[pulumi.Input[bool]] = None,
- public_ip_should_deallocate: Optional[pulumi.Input[bool]] = None,
- should_terminate_vm: Optional[pulumi.Input[bool]] = None,
- snapshot_should_deallocate: Optional[pulumi.Input[bool]] = None,
- disk_ttl_in_hours: Optional[pulumi.Input[int]] = None,
- network_ttl_in_hours: Optional[pulumi.Input[int]] = None,
- public_ip_ttl_in_hours: Optional[pulumi.Input[int]] = None,
- snapshot_ttl_in_hours: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if disk_should_deallocate is None and 'diskShouldDeallocate' in kwargs:
- disk_should_deallocate = kwargs['diskShouldDeallocate']
- if disk_should_deallocate is None:
- raise TypeError("Missing 'disk_should_deallocate' argument")
- if network_should_deallocate is None and 'networkShouldDeallocate' in kwargs:
- network_should_deallocate = kwargs['networkShouldDeallocate']
- if network_should_deallocate is None:
- raise TypeError("Missing 'network_should_deallocate' argument")
- if public_ip_should_deallocate is None and 'publicIpShouldDeallocate' in kwargs:
- public_ip_should_deallocate = kwargs['publicIpShouldDeallocate']
- if public_ip_should_deallocate is None:
- raise TypeError("Missing 'public_ip_should_deallocate' argument")
- if should_terminate_vm is None and 'shouldTerminateVm' in kwargs:
- should_terminate_vm = kwargs['shouldTerminateVm']
- if should_terminate_vm is None:
- raise TypeError("Missing 'should_terminate_vm' argument")
- if snapshot_should_deallocate is None and 'snapshotShouldDeallocate' in kwargs:
- snapshot_should_deallocate = kwargs['snapshotShouldDeallocate']
- if snapshot_should_deallocate is None:
- raise TypeError("Missing 'snapshot_should_deallocate' argument")
- if disk_ttl_in_hours is None and 'diskTtlInHours' in kwargs:
- disk_ttl_in_hours = kwargs['diskTtlInHours']
- if network_ttl_in_hours is None and 'networkTtlInHours' in kwargs:
- network_ttl_in_hours = kwargs['networkTtlInHours']
- if public_ip_ttl_in_hours is None and 'publicIpTtlInHours' in kwargs:
- public_ip_ttl_in_hours = kwargs['publicIpTtlInHours']
- if snapshot_ttl_in_hours is None and 'snapshotTtlInHours' in kwargs:
- snapshot_ttl_in_hours = kwargs['snapshotTtlInHours']
-
- _setter("disk_should_deallocate", disk_should_deallocate)
- _setter("network_should_deallocate", network_should_deallocate)
- _setter("public_ip_should_deallocate", public_ip_should_deallocate)
- _setter("should_terminate_vm", should_terminate_vm)
- _setter("snapshot_should_deallocate", snapshot_should_deallocate)
+ pulumi.set(__self__, "disk_should_deallocate", disk_should_deallocate)
+ pulumi.set(__self__, "network_should_deallocate", network_should_deallocate)
+ pulumi.set(__self__, "public_ip_should_deallocate", public_ip_should_deallocate)
+ pulumi.set(__self__, "should_terminate_vm", should_terminate_vm)
+ pulumi.set(__self__, "snapshot_should_deallocate", snapshot_should_deallocate)
if disk_ttl_in_hours is not None:
- _setter("disk_ttl_in_hours", disk_ttl_in_hours)
+ pulumi.set(__self__, "disk_ttl_in_hours", disk_ttl_in_hours)
if network_ttl_in_hours is not None:
- _setter("network_ttl_in_hours", network_ttl_in_hours)
+ pulumi.set(__self__, "network_ttl_in_hours", network_ttl_in_hours)
if public_ip_ttl_in_hours is not None:
- _setter("public_ip_ttl_in_hours", public_ip_ttl_in_hours)
+ pulumi.set(__self__, "public_ip_ttl_in_hours", public_ip_ttl_in_hours)
if snapshot_ttl_in_hours is not None:
- _setter("snapshot_ttl_in_hours", snapshot_ttl_in_hours)
+ pulumi.set(__self__, "snapshot_ttl_in_hours", snapshot_ttl_in_hours)
@property
@pulumi.getter(name="diskShouldDeallocate")
@@ -1257,42 +851,11 @@ def __init__(__self__, *,
data_disk_resource_group_name: pulumi.Input[str],
should_deallocate: pulumi.Input[bool],
ttl_in_hours: Optional[pulumi.Input[int]] = None):
- StatefulNodeAzureDetachDataDiskArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- data_disk_name=data_disk_name,
- data_disk_resource_group_name=data_disk_resource_group_name,
- should_deallocate=should_deallocate,
- ttl_in_hours=ttl_in_hours,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- data_disk_name: Optional[pulumi.Input[str]] = None,
- data_disk_resource_group_name: Optional[pulumi.Input[str]] = None,
- should_deallocate: Optional[pulumi.Input[bool]] = None,
- ttl_in_hours: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if data_disk_name is None and 'dataDiskName' in kwargs:
- data_disk_name = kwargs['dataDiskName']
- if data_disk_name is None:
- raise TypeError("Missing 'data_disk_name' argument")
- if data_disk_resource_group_name is None and 'dataDiskResourceGroupName' in kwargs:
- data_disk_resource_group_name = kwargs['dataDiskResourceGroupName']
- if data_disk_resource_group_name is None:
- raise TypeError("Missing 'data_disk_resource_group_name' argument")
- if should_deallocate is None and 'shouldDeallocate' in kwargs:
- should_deallocate = kwargs['shouldDeallocate']
- if should_deallocate is None:
- raise TypeError("Missing 'should_deallocate' argument")
- if ttl_in_hours is None and 'ttlInHours' in kwargs:
- ttl_in_hours = kwargs['ttlInHours']
-
- _setter("data_disk_name", data_disk_name)
- _setter("data_disk_resource_group_name", data_disk_resource_group_name)
- _setter("should_deallocate", should_deallocate)
+ pulumi.set(__self__, "data_disk_name", data_disk_name)
+ pulumi.set(__self__, "data_disk_resource_group_name", data_disk_resource_group_name)
+ pulumi.set(__self__, "should_deallocate", should_deallocate)
if ttl_in_hours is not None:
- _setter("ttl_in_hours", ttl_in_hours)
+ pulumi.set(__self__, "ttl_in_hours", ttl_in_hours)
@property
@pulumi.getter(name="dataDiskName")
@@ -1341,56 +904,15 @@ def __init__(__self__, *,
type: pulumi.Input[str],
protected_settings: Optional[pulumi.Input[Mapping[str, Any]]] = None,
public_settings: Optional[pulumi.Input[Mapping[str, Any]]] = None):
- StatefulNodeAzureExtensionArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- api_version=api_version,
- minor_version_auto_upgrade=minor_version_auto_upgrade,
- name=name,
- publisher=publisher,
- type=type,
- protected_settings=protected_settings,
- public_settings=public_settings,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- api_version: Optional[pulumi.Input[str]] = None,
- minor_version_auto_upgrade: Optional[pulumi.Input[bool]] = None,
- name: Optional[pulumi.Input[str]] = None,
- publisher: Optional[pulumi.Input[str]] = None,
- type: Optional[pulumi.Input[str]] = None,
- protected_settings: Optional[pulumi.Input[Mapping[str, Any]]] = None,
- public_settings: Optional[pulumi.Input[Mapping[str, Any]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if api_version is None and 'apiVersion' in kwargs:
- api_version = kwargs['apiVersion']
- if api_version is None:
- raise TypeError("Missing 'api_version' argument")
- if minor_version_auto_upgrade is None and 'minorVersionAutoUpgrade' in kwargs:
- minor_version_auto_upgrade = kwargs['minorVersionAutoUpgrade']
- if minor_version_auto_upgrade is None:
- raise TypeError("Missing 'minor_version_auto_upgrade' argument")
- if name is None:
- raise TypeError("Missing 'name' argument")
- if publisher is None:
- raise TypeError("Missing 'publisher' argument")
- if type is None:
- raise TypeError("Missing 'type' argument")
- if protected_settings is None and 'protectedSettings' in kwargs:
- protected_settings = kwargs['protectedSettings']
- if public_settings is None and 'publicSettings' in kwargs:
- public_settings = kwargs['publicSettings']
-
- _setter("api_version", api_version)
- _setter("minor_version_auto_upgrade", minor_version_auto_upgrade)
- _setter("name", name)
- _setter("publisher", publisher)
- _setter("type", type)
+ pulumi.set(__self__, "api_version", api_version)
+ pulumi.set(__self__, "minor_version_auto_upgrade", minor_version_auto_upgrade)
+ pulumi.set(__self__, "name", name)
+ pulumi.set(__self__, "publisher", publisher)
+ pulumi.set(__self__, "type", type)
if protected_settings is not None:
- _setter("protected_settings", protected_settings)
+ pulumi.set(__self__, "protected_settings", protected_settings)
if public_settings is not None:
- _setter("public_settings", public_settings)
+ pulumi.set(__self__, "public_settings", public_settings)
@property
@pulumi.getter(name="apiVersion")
@@ -1463,41 +985,12 @@ def __init__(__self__, *,
health_check_types: pulumi.Input[Sequence[pulumi.Input[str]]],
grace_period: Optional[pulumi.Input[int]] = None,
unhealthy_duration: Optional[pulumi.Input[int]] = None):
- StatefulNodeAzureHealthArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- auto_healing=auto_healing,
- health_check_types=health_check_types,
- grace_period=grace_period,
- unhealthy_duration=unhealthy_duration,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- auto_healing: Optional[pulumi.Input[bool]] = None,
- health_check_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- grace_period: Optional[pulumi.Input[int]] = None,
- unhealthy_duration: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if auto_healing is None and 'autoHealing' in kwargs:
- auto_healing = kwargs['autoHealing']
- if auto_healing is None:
- raise TypeError("Missing 'auto_healing' argument")
- if health_check_types is None and 'healthCheckTypes' in kwargs:
- health_check_types = kwargs['healthCheckTypes']
- if health_check_types is None:
- raise TypeError("Missing 'health_check_types' argument")
- if grace_period is None and 'gracePeriod' in kwargs:
- grace_period = kwargs['gracePeriod']
- if unhealthy_duration is None and 'unhealthyDuration' in kwargs:
- unhealthy_duration = kwargs['unhealthyDuration']
-
- _setter("auto_healing", auto_healing)
- _setter("health_check_types", health_check_types)
+ pulumi.set(__self__, "auto_healing", auto_healing)
+ pulumi.set(__self__, "health_check_types", health_check_types)
if grace_period is not None:
- _setter("grace_period", grace_period)
+ pulumi.set(__self__, "grace_period", grace_period)
if unhealthy_duration is not None:
- _setter("unhealthy_duration", unhealthy_duration)
+ pulumi.set(__self__, "unhealthy_duration", unhealthy_duration)
@property
@pulumi.getter(name="autoHealing")
@@ -1542,31 +1035,12 @@ def __init__(__self__, *,
custom_images: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureImageCustomImageArgs']]]] = None,
galleries: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureImageGalleryArgs']]]] = None,
marketplace_images: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureImageMarketplaceImageArgs']]]] = None):
- StatefulNodeAzureImageArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- custom_images=custom_images,
- galleries=galleries,
- marketplace_images=marketplace_images,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- custom_images: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureImageCustomImageArgs']]]] = None,
- galleries: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureImageGalleryArgs']]]] = None,
- marketplace_images: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureImageMarketplaceImageArgs']]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if custom_images is None and 'customImages' in kwargs:
- custom_images = kwargs['customImages']
- if marketplace_images is None and 'marketplaceImages' in kwargs:
- marketplace_images = kwargs['marketplaceImages']
-
if custom_images is not None:
- _setter("custom_images", custom_images)
+ pulumi.set(__self__, "custom_images", custom_images)
if galleries is not None:
- _setter("galleries", galleries)
+ pulumi.set(__self__, "galleries", galleries)
if marketplace_images is not None:
- _setter("marketplace_images", marketplace_images)
+ pulumi.set(__self__, "marketplace_images", marketplace_images)
@property
@pulumi.getter(name="customImages")
@@ -1601,27 +1075,8 @@ class StatefulNodeAzureImageCustomImageArgs:
def __init__(__self__, *,
custom_image_resource_group_name: pulumi.Input[str],
name: pulumi.Input[str]):
- StatefulNodeAzureImageCustomImageArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- custom_image_resource_group_name=custom_image_resource_group_name,
- name=name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- custom_image_resource_group_name: Optional[pulumi.Input[str]] = None,
- name: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if custom_image_resource_group_name is None and 'customImageResourceGroupName' in kwargs:
- custom_image_resource_group_name = kwargs['customImageResourceGroupName']
- if custom_image_resource_group_name is None:
- raise TypeError("Missing 'custom_image_resource_group_name' argument")
- if name is None:
- raise TypeError("Missing 'name' argument")
-
- _setter("custom_image_resource_group_name", custom_image_resource_group_name)
- _setter("name", name)
+ pulumi.set(__self__, "custom_image_resource_group_name", custom_image_resource_group_name)
+ pulumi.set(__self__, "name", name)
@property
@pulumi.getter(name="customImageResourceGroupName")
@@ -1649,43 +1104,10 @@ def __init__(__self__, *,
gallery_resource_group_name: pulumi.Input[str],
image_name: pulumi.Input[str],
version_name: pulumi.Input[str]):
- StatefulNodeAzureImageGalleryArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- gallery_name=gallery_name,
- gallery_resource_group_name=gallery_resource_group_name,
- image_name=image_name,
- version_name=version_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- gallery_name: Optional[pulumi.Input[str]] = None,
- gallery_resource_group_name: Optional[pulumi.Input[str]] = None,
- image_name: Optional[pulumi.Input[str]] = None,
- version_name: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if gallery_name is None and 'galleryName' in kwargs:
- gallery_name = kwargs['galleryName']
- if gallery_name is None:
- raise TypeError("Missing 'gallery_name' argument")
- if gallery_resource_group_name is None and 'galleryResourceGroupName' in kwargs:
- gallery_resource_group_name = kwargs['galleryResourceGroupName']
- if gallery_resource_group_name is None:
- raise TypeError("Missing 'gallery_resource_group_name' argument")
- if image_name is None and 'imageName' in kwargs:
- image_name = kwargs['imageName']
- if image_name is None:
- raise TypeError("Missing 'image_name' argument")
- if version_name is None and 'versionName' in kwargs:
- version_name = kwargs['versionName']
- if version_name is None:
- raise TypeError("Missing 'version_name' argument")
-
- _setter("gallery_name", gallery_name)
- _setter("gallery_resource_group_name", gallery_resource_group_name)
- _setter("image_name", image_name)
- _setter("version_name", version_name)
+ pulumi.set(__self__, "gallery_name", gallery_name)
+ pulumi.set(__self__, "gallery_resource_group_name", gallery_resource_group_name)
+ pulumi.set(__self__, "image_name", image_name)
+ pulumi.set(__self__, "version_name", version_name)
@property
@pulumi.getter(name="galleryName")
@@ -1731,35 +1153,10 @@ def __init__(__self__, *,
publisher: pulumi.Input[str],
sku: pulumi.Input[str],
version: pulumi.Input[str]):
- StatefulNodeAzureImageMarketplaceImageArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- offer=offer,
- publisher=publisher,
- sku=sku,
- version=version,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- offer: Optional[pulumi.Input[str]] = None,
- publisher: Optional[pulumi.Input[str]] = None,
- sku: Optional[pulumi.Input[str]] = None,
- version: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if offer is None:
- raise TypeError("Missing 'offer' argument")
- if publisher is None:
- raise TypeError("Missing 'publisher' argument")
- if sku is None:
- raise TypeError("Missing 'sku' argument")
- if version is None:
- raise TypeError("Missing 'version' argument")
-
- _setter("offer", offer)
- _setter("publisher", publisher)
- _setter("sku", sku)
- _setter("version", version)
+ pulumi.set(__self__, "offer", offer)
+ pulumi.set(__self__, "publisher", publisher)
+ pulumi.set(__self__, "sku", sku)
+ pulumi.set(__self__, "version", version)
@property
@pulumi.getter
@@ -1805,41 +1202,12 @@ def __init__(__self__, *,
resource_group_name: pulumi.Input[str],
draining_timeout: Optional[pulumi.Input[int]] = None,
resources_retention_time: Optional[pulumi.Input[int]] = None):
- StatefulNodeAzureImportVmArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- original_vm_name=original_vm_name,
- resource_group_name=resource_group_name,
- draining_timeout=draining_timeout,
- resources_retention_time=resources_retention_time,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- original_vm_name: Optional[pulumi.Input[str]] = None,
- resource_group_name: Optional[pulumi.Input[str]] = None,
- draining_timeout: Optional[pulumi.Input[int]] = None,
- resources_retention_time: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if original_vm_name is None and 'originalVmName' in kwargs:
- original_vm_name = kwargs['originalVmName']
- if original_vm_name is None:
- raise TypeError("Missing 'original_vm_name' argument")
- if resource_group_name is None and 'resourceGroupName' in kwargs:
- resource_group_name = kwargs['resourceGroupName']
- if resource_group_name is None:
- raise TypeError("Missing 'resource_group_name' argument")
- if draining_timeout is None and 'drainingTimeout' in kwargs:
- draining_timeout = kwargs['drainingTimeout']
- if resources_retention_time is None and 'resourcesRetentionTime' in kwargs:
- resources_retention_time = kwargs['resourcesRetentionTime']
-
- _setter("original_vm_name", original_vm_name)
- _setter("resource_group_name", resource_group_name)
+ pulumi.set(__self__, "original_vm_name", original_vm_name)
+ pulumi.set(__self__, "resource_group_name", resource_group_name)
if draining_timeout is not None:
- _setter("draining_timeout", draining_timeout)
+ pulumi.set(__self__, "draining_timeout", draining_timeout)
if resources_retention_time is not None:
- _setter("resources_retention_time", resources_retention_time)
+ pulumi.set(__self__, "resources_retention_time", resources_retention_time)
@property
@pulumi.getter(name="originalVmName")
@@ -1886,43 +1254,12 @@ def __init__(__self__, *,
resource_group_name: pulumi.Input[str],
type: pulumi.Input[str],
sku: Optional[pulumi.Input[str]] = None):
- StatefulNodeAzureLoadBalancerArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- backend_pool_names=backend_pool_names,
- name=name,
- resource_group_name=resource_group_name,
- type=type,
- sku=sku,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- backend_pool_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- name: Optional[pulumi.Input[str]] = None,
- resource_group_name: Optional[pulumi.Input[str]] = None,
- type: Optional[pulumi.Input[str]] = None,
- sku: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if backend_pool_names is None and 'backendPoolNames' in kwargs:
- backend_pool_names = kwargs['backendPoolNames']
- if backend_pool_names is None:
- raise TypeError("Missing 'backend_pool_names' argument")
- if name is None:
- raise TypeError("Missing 'name' argument")
- if resource_group_name is None and 'resourceGroupName' in kwargs:
- resource_group_name = kwargs['resourceGroupName']
- if resource_group_name is None:
- raise TypeError("Missing 'resource_group_name' argument")
- if type is None:
- raise TypeError("Missing 'type' argument")
-
- _setter("backend_pool_names", backend_pool_names)
- _setter("name", name)
- _setter("resource_group_name", resource_group_name)
- _setter("type", type)
+ pulumi.set(__self__, "backend_pool_names", backend_pool_names)
+ pulumi.set(__self__, "name", name)
+ pulumi.set(__self__, "resource_group_name", resource_group_name)
+ pulumi.set(__self__, "type", type)
if sku is not None:
- _setter("sku", sku)
+ pulumi.set(__self__, "sku", sku)
@property
@pulumi.getter(name="backendPoolNames")
@@ -1976,32 +1313,11 @@ def __init__(__self__, *,
user_name: pulumi.Input[str],
password: Optional[pulumi.Input[str]] = None,
ssh_public_key: Optional[pulumi.Input[str]] = None):
- StatefulNodeAzureLoginArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- user_name=user_name,
- password=password,
- ssh_public_key=ssh_public_key,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- user_name: Optional[pulumi.Input[str]] = None,
- password: Optional[pulumi.Input[str]] = None,
- ssh_public_key: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if user_name is None and 'userName' in kwargs:
- user_name = kwargs['userName']
- if user_name is None:
- raise TypeError("Missing 'user_name' argument")
- if ssh_public_key is None and 'sshPublicKey' in kwargs:
- ssh_public_key = kwargs['sshPublicKey']
-
- _setter("user_name", user_name)
+ pulumi.set(__self__, "user_name", user_name)
if password is not None:
- _setter("password", password)
+ pulumi.set(__self__, "password", password)
if ssh_public_key is not None:
- _setter("ssh_public_key", ssh_public_key)
+ pulumi.set(__self__, "ssh_public_key", ssh_public_key)
@property
@pulumi.getter(name="userName")
@@ -2036,27 +1352,8 @@ class StatefulNodeAzureManagedServiceIdentityArgs:
def __init__(__self__, *,
name: pulumi.Input[str],
resource_group_name: pulumi.Input[str]):
- StatefulNodeAzureManagedServiceIdentityArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- resource_group_name=resource_group_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- resource_group_name: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
- if resource_group_name is None and 'resourceGroupName' in kwargs:
- resource_group_name = kwargs['resourceGroupName']
- if resource_group_name is None:
- raise TypeError("Missing 'resource_group_name' argument")
-
- _setter("name", name)
- _setter("resource_group_name", resource_group_name)
+ pulumi.set(__self__, "name", name)
+ pulumi.set(__self__, "resource_group_name", resource_group_name)
@property
@pulumi.getter
@@ -2083,36 +1380,9 @@ def __init__(__self__, *,
network_interfaces: pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureNetworkNetworkInterfaceArgs']]],
network_resource_group_name: pulumi.Input[str],
virtual_network_name: pulumi.Input[str]):
- StatefulNodeAzureNetworkArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- network_interfaces=network_interfaces,
- network_resource_group_name=network_resource_group_name,
- virtual_network_name=virtual_network_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- network_interfaces: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureNetworkNetworkInterfaceArgs']]]] = None,
- network_resource_group_name: Optional[pulumi.Input[str]] = None,
- virtual_network_name: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if network_interfaces is None and 'networkInterfaces' in kwargs:
- network_interfaces = kwargs['networkInterfaces']
- if network_interfaces is None:
- raise TypeError("Missing 'network_interfaces' argument")
- if network_resource_group_name is None and 'networkResourceGroupName' in kwargs:
- network_resource_group_name = kwargs['networkResourceGroupName']
- if network_resource_group_name is None:
- raise TypeError("Missing 'network_resource_group_name' argument")
- if virtual_network_name is None and 'virtualNetworkName' in kwargs:
- virtual_network_name = kwargs['virtualNetworkName']
- if virtual_network_name is None:
- raise TypeError("Missing 'virtual_network_name' argument")
-
- _setter("network_interfaces", network_interfaces)
- _setter("network_resource_group_name", network_resource_group_name)
- _setter("virtual_network_name", virtual_network_name)
+ pulumi.set(__self__, "network_interfaces", network_interfaces)
+ pulumi.set(__self__, "network_resource_group_name", network_resource_group_name)
+ pulumi.set(__self__, "virtual_network_name", virtual_network_name)
@property
@pulumi.getter(name="networkInterfaces")
@@ -2155,77 +1425,24 @@ def __init__(__self__, *,
private_ip_addresses: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
public_ip_sku: Optional[pulumi.Input[str]] = None,
public_ips: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureNetworkNetworkInterfacePublicIpArgs']]]] = None):
- StatefulNodeAzureNetworkNetworkInterfaceArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- is_primary=is_primary,
- subnet_name=subnet_name,
- additional_ip_configurations=additional_ip_configurations,
- application_security_groups=application_security_groups,
- assign_public_ip=assign_public_ip,
- enable_ip_forwarding=enable_ip_forwarding,
- network_security_groups=network_security_groups,
- private_ip_addresses=private_ip_addresses,
- public_ip_sku=public_ip_sku,
- public_ips=public_ips,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- is_primary: Optional[pulumi.Input[bool]] = None,
- subnet_name: Optional[pulumi.Input[str]] = None,
- additional_ip_configurations: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureNetworkNetworkInterfaceAdditionalIpConfigurationArgs']]]] = None,
- application_security_groups: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureNetworkNetworkInterfaceApplicationSecurityGroupArgs']]]] = None,
- assign_public_ip: Optional[pulumi.Input[bool]] = None,
- enable_ip_forwarding: Optional[pulumi.Input[bool]] = None,
- network_security_groups: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureNetworkNetworkInterfaceNetworkSecurityGroupArgs']]]] = None,
- private_ip_addresses: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- public_ip_sku: Optional[pulumi.Input[str]] = None,
- public_ips: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureNetworkNetworkInterfacePublicIpArgs']]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if is_primary is None and 'isPrimary' in kwargs:
- is_primary = kwargs['isPrimary']
- if is_primary is None:
- raise TypeError("Missing 'is_primary' argument")
- if subnet_name is None and 'subnetName' in kwargs:
- subnet_name = kwargs['subnetName']
- if subnet_name is None:
- raise TypeError("Missing 'subnet_name' argument")
- if additional_ip_configurations is None and 'additionalIpConfigurations' in kwargs:
- additional_ip_configurations = kwargs['additionalIpConfigurations']
- if application_security_groups is None and 'applicationSecurityGroups' in kwargs:
- application_security_groups = kwargs['applicationSecurityGroups']
- if assign_public_ip is None and 'assignPublicIp' in kwargs:
- assign_public_ip = kwargs['assignPublicIp']
- if enable_ip_forwarding is None and 'enableIpForwarding' in kwargs:
- enable_ip_forwarding = kwargs['enableIpForwarding']
- if network_security_groups is None and 'networkSecurityGroups' in kwargs:
- network_security_groups = kwargs['networkSecurityGroups']
- if private_ip_addresses is None and 'privateIpAddresses' in kwargs:
- private_ip_addresses = kwargs['privateIpAddresses']
- if public_ip_sku is None and 'publicIpSku' in kwargs:
- public_ip_sku = kwargs['publicIpSku']
- if public_ips is None and 'publicIps' in kwargs:
- public_ips = kwargs['publicIps']
-
- _setter("is_primary", is_primary)
- _setter("subnet_name", subnet_name)
+ pulumi.set(__self__, "is_primary", is_primary)
+ pulumi.set(__self__, "subnet_name", subnet_name)
if additional_ip_configurations is not None:
- _setter("additional_ip_configurations", additional_ip_configurations)
+ pulumi.set(__self__, "additional_ip_configurations", additional_ip_configurations)
if application_security_groups is not None:
- _setter("application_security_groups", application_security_groups)
+ pulumi.set(__self__, "application_security_groups", application_security_groups)
if assign_public_ip is not None:
- _setter("assign_public_ip", assign_public_ip)
+ pulumi.set(__self__, "assign_public_ip", assign_public_ip)
if enable_ip_forwarding is not None:
- _setter("enable_ip_forwarding", enable_ip_forwarding)
+ pulumi.set(__self__, "enable_ip_forwarding", enable_ip_forwarding)
if network_security_groups is not None:
- _setter("network_security_groups", network_security_groups)
+ pulumi.set(__self__, "network_security_groups", network_security_groups)
if private_ip_addresses is not None:
- _setter("private_ip_addresses", private_ip_addresses)
+ pulumi.set(__self__, "private_ip_addresses", private_ip_addresses)
if public_ip_sku is not None:
- _setter("public_ip_sku", public_ip_sku)
+ pulumi.set(__self__, "public_ip_sku", public_ip_sku)
if public_ips is not None:
- _setter("public_ips", public_ips)
+ pulumi.set(__self__, "public_ips", public_ips)
@property
@pulumi.getter(name="isPrimary")
@@ -2323,27 +1540,8 @@ class StatefulNodeAzureNetworkNetworkInterfaceAdditionalIpConfigurationArgs:
def __init__(__self__, *,
name: pulumi.Input[str],
private_ip_address_version: pulumi.Input[str]):
- StatefulNodeAzureNetworkNetworkInterfaceAdditionalIpConfigurationArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- private_ip_address_version=private_ip_address_version,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- private_ip_address_version: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
- if private_ip_address_version is None and 'privateIpAddressVersion' in kwargs:
- private_ip_address_version = kwargs['privateIpAddressVersion']
- if private_ip_address_version is None:
- raise TypeError("Missing 'private_ip_address_version' argument")
-
- _setter("name", name)
- _setter("private_ip_address_version", private_ip_address_version)
+ pulumi.set(__self__, "name", name)
+ pulumi.set(__self__, "private_ip_address_version", private_ip_address_version)
@property
@pulumi.getter
@@ -2369,27 +1567,8 @@ class StatefulNodeAzureNetworkNetworkInterfaceApplicationSecurityGroupArgs:
def __init__(__self__, *,
name: pulumi.Input[str],
network_resource_group_name: pulumi.Input[str]):
- StatefulNodeAzureNetworkNetworkInterfaceApplicationSecurityGroupArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- network_resource_group_name=network_resource_group_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- network_resource_group_name: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
- if network_resource_group_name is None and 'networkResourceGroupName' in kwargs:
- network_resource_group_name = kwargs['networkResourceGroupName']
- if network_resource_group_name is None:
- raise TypeError("Missing 'network_resource_group_name' argument")
-
- _setter("name", name)
- _setter("network_resource_group_name", network_resource_group_name)
+ pulumi.set(__self__, "name", name)
+ pulumi.set(__self__, "network_resource_group_name", network_resource_group_name)
@property
@pulumi.getter
@@ -2415,25 +1594,10 @@ class StatefulNodeAzureNetworkNetworkInterfaceNetworkSecurityGroupArgs:
def __init__(__self__, *,
name: Optional[pulumi.Input[str]] = None,
network_resource_group_name: Optional[pulumi.Input[str]] = None):
- StatefulNodeAzureNetworkNetworkInterfaceNetworkSecurityGroupArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- network_resource_group_name=network_resource_group_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- network_resource_group_name: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if network_resource_group_name is None and 'networkResourceGroupName' in kwargs:
- network_resource_group_name = kwargs['networkResourceGroupName']
-
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if network_resource_group_name is not None:
- _setter("network_resource_group_name", network_resource_group_name)
+ pulumi.set(__self__, "network_resource_group_name", network_resource_group_name)
@property
@pulumi.getter
@@ -2459,27 +1623,8 @@ class StatefulNodeAzureNetworkNetworkInterfacePublicIpArgs:
def __init__(__self__, *,
name: pulumi.Input[str],
network_resource_group_name: pulumi.Input[str]):
- StatefulNodeAzureNetworkNetworkInterfacePublicIpArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- network_resource_group_name=network_resource_group_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- network_resource_group_name: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
- if network_resource_group_name is None and 'networkResourceGroupName' in kwargs:
- network_resource_group_name = kwargs['networkResourceGroupName']
- if network_resource_group_name is None:
- raise TypeError("Missing 'network_resource_group_name' argument")
-
- _setter("name", name)
- _setter("network_resource_group_name", network_resource_group_name)
+ pulumi.set(__self__, "name", name)
+ pulumi.set(__self__, "network_resource_group_name", network_resource_group_name)
@property
@pulumi.getter
@@ -2505,26 +1650,9 @@ class StatefulNodeAzureOsDiskArgs:
def __init__(__self__, *,
type: pulumi.Input[str],
size_gb: Optional[pulumi.Input[int]] = None):
- StatefulNodeAzureOsDiskArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- type=type,
- size_gb=size_gb,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- type: Optional[pulumi.Input[str]] = None,
- size_gb: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if type is None:
- raise TypeError("Missing 'type' argument")
- if size_gb is None and 'sizeGb' in kwargs:
- size_gb = kwargs['sizeGb']
-
- _setter("type", type)
+ pulumi.set(__self__, "type", type)
if size_gb is not None:
- _setter("size_gb", size_gb)
+ pulumi.set(__self__, "size_gb", size_gb)
@property
@pulumi.getter
@@ -2551,34 +1679,9 @@ def __init__(__self__, *,
cron_expression: pulumi.Input[str],
is_enabled: pulumi.Input[bool],
type: pulumi.Input[str]):
- StatefulNodeAzureSchedulingTaskArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cron_expression=cron_expression,
- is_enabled=is_enabled,
- type=type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cron_expression: Optional[pulumi.Input[str]] = None,
- is_enabled: Optional[pulumi.Input[bool]] = None,
- type: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cron_expression is None and 'cronExpression' in kwargs:
- cron_expression = kwargs['cronExpression']
- if cron_expression is None:
- raise TypeError("Missing 'cron_expression' argument")
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
- if is_enabled is None:
- raise TypeError("Missing 'is_enabled' argument")
- if type is None:
- raise TypeError("Missing 'type' argument")
-
- _setter("cron_expression", cron_expression)
- _setter("is_enabled", is_enabled)
- _setter("type", type)
+ pulumi.set(__self__, "cron_expression", cron_expression)
+ pulumi.set(__self__, "is_enabled", is_enabled)
+ pulumi.set(__self__, "type", type)
@property
@pulumi.getter(name="cronExpression")
@@ -2613,29 +1716,8 @@ class StatefulNodeAzureSecretArgs:
def __init__(__self__, *,
source_vaults: pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureSecretSourceVaultArgs']]],
vault_certificates: pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureSecretVaultCertificateArgs']]]):
- StatefulNodeAzureSecretArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- source_vaults=source_vaults,
- vault_certificates=vault_certificates,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- source_vaults: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureSecretSourceVaultArgs']]]] = None,
- vault_certificates: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureSecretVaultCertificateArgs']]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if source_vaults is None and 'sourceVaults' in kwargs:
- source_vaults = kwargs['sourceVaults']
- if source_vaults is None:
- raise TypeError("Missing 'source_vaults' argument")
- if vault_certificates is None and 'vaultCertificates' in kwargs:
- vault_certificates = kwargs['vaultCertificates']
- if vault_certificates is None:
- raise TypeError("Missing 'vault_certificates' argument")
-
- _setter("source_vaults", source_vaults)
- _setter("vault_certificates", vault_certificates)
+ pulumi.set(__self__, "source_vaults", source_vaults)
+ pulumi.set(__self__, "vault_certificates", vault_certificates)
@property
@pulumi.getter(name="sourceVaults")
@@ -2661,27 +1743,8 @@ class StatefulNodeAzureSecretSourceVaultArgs:
def __init__(__self__, *,
name: pulumi.Input[str],
resource_group_name: pulumi.Input[str]):
- StatefulNodeAzureSecretSourceVaultArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- resource_group_name=resource_group_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- resource_group_name: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
- if resource_group_name is None and 'resourceGroupName' in kwargs:
- resource_group_name = kwargs['resourceGroupName']
- if resource_group_name is None:
- raise TypeError("Missing 'resource_group_name' argument")
-
- _setter("name", name)
- _setter("resource_group_name", resource_group_name)
+ pulumi.set(__self__, "name", name)
+ pulumi.set(__self__, "resource_group_name", resource_group_name)
@property
@pulumi.getter
@@ -2707,27 +1770,10 @@ class StatefulNodeAzureSecretVaultCertificateArgs:
def __init__(__self__, *,
certificate_store: Optional[pulumi.Input[str]] = None,
certificate_url: Optional[pulumi.Input[str]] = None):
- StatefulNodeAzureSecretVaultCertificateArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- certificate_store=certificate_store,
- certificate_url=certificate_url,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- certificate_store: Optional[pulumi.Input[str]] = None,
- certificate_url: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if certificate_store is None and 'certificateStore' in kwargs:
- certificate_store = kwargs['certificateStore']
- if certificate_url is None and 'certificateUrl' in kwargs:
- certificate_url = kwargs['certificateUrl']
-
if certificate_store is not None:
- _setter("certificate_store", certificate_store)
+ pulumi.set(__self__, "certificate_store", certificate_store)
if certificate_url is not None:
- _setter("certificate_url", certificate_url)
+ pulumi.set(__self__, "certificate_url", certificate_url)
@property
@pulumi.getter(name="certificateStore")
@@ -2754,33 +1800,12 @@ def __init__(__self__, *,
secure_boot_enabled: Optional[pulumi.Input[bool]] = None,
security_type: Optional[pulumi.Input[str]] = None,
vtpm_enabled: Optional[pulumi.Input[bool]] = None):
- StatefulNodeAzureSecurityArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- secure_boot_enabled=secure_boot_enabled,
- security_type=security_type,
- vtpm_enabled=vtpm_enabled,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- secure_boot_enabled: Optional[pulumi.Input[bool]] = None,
- security_type: Optional[pulumi.Input[str]] = None,
- vtpm_enabled: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if secure_boot_enabled is None and 'secureBootEnabled' in kwargs:
- secure_boot_enabled = kwargs['secureBootEnabled']
- if security_type is None and 'securityType' in kwargs:
- security_type = kwargs['securityType']
- if vtpm_enabled is None and 'vtpmEnabled' in kwargs:
- vtpm_enabled = kwargs['vtpmEnabled']
-
if secure_boot_enabled is not None:
- _setter("secure_boot_enabled", secure_boot_enabled)
+ pulumi.set(__self__, "secure_boot_enabled", secure_boot_enabled)
if security_type is not None:
- _setter("security_type", security_type)
+ pulumi.set(__self__, "security_type", security_type)
if vtpm_enabled is not None:
- _setter("vtpm_enabled", vtpm_enabled)
+ pulumi.set(__self__, "vtpm_enabled", vtpm_enabled)
@property
@pulumi.getter(name="secureBootEnabled")
@@ -2815,25 +1840,8 @@ class StatefulNodeAzureSignalArgs:
def __init__(__self__, *,
timeout: pulumi.Input[int],
type: pulumi.Input[str]):
- StatefulNodeAzureSignalArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- timeout=timeout,
- type=type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- timeout: Optional[pulumi.Input[int]] = None,
- type: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if timeout is None:
- raise TypeError("Missing 'timeout' argument")
- if type is None:
- raise TypeError("Missing 'type' argument")
-
- _setter("timeout", timeout)
- _setter("type", type)
+ pulumi.set(__self__, "timeout", timeout)
+ pulumi.set(__self__, "type", type)
@property
@pulumi.getter
@@ -2863,52 +1871,17 @@ def __init__(__self__, *,
optimization_windows: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
preferred_life_cycle: Optional[pulumi.Input[str]] = None,
revert_to_spot: Optional[pulumi.Input['StatefulNodeAzureStrategyRevertToSpotArgs']] = None):
- StatefulNodeAzureStrategyArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- fallback_to_on_demand=fallback_to_on_demand,
- capacity_reservations=capacity_reservations,
- draining_timeout=draining_timeout,
- optimization_windows=optimization_windows,
- preferred_life_cycle=preferred_life_cycle,
- revert_to_spot=revert_to_spot,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- fallback_to_on_demand: Optional[pulumi.Input[bool]] = None,
- capacity_reservations: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureStrategyCapacityReservationArgs']]]] = None,
- draining_timeout: Optional[pulumi.Input[int]] = None,
- optimization_windows: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- preferred_life_cycle: Optional[pulumi.Input[str]] = None,
- revert_to_spot: Optional[pulumi.Input['StatefulNodeAzureStrategyRevertToSpotArgs']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if fallback_to_on_demand is None and 'fallbackToOnDemand' in kwargs:
- fallback_to_on_demand = kwargs['fallbackToOnDemand']
- if fallback_to_on_demand is None:
- raise TypeError("Missing 'fallback_to_on_demand' argument")
- if capacity_reservations is None and 'capacityReservations' in kwargs:
- capacity_reservations = kwargs['capacityReservations']
- if draining_timeout is None and 'drainingTimeout' in kwargs:
- draining_timeout = kwargs['drainingTimeout']
- if optimization_windows is None and 'optimizationWindows' in kwargs:
- optimization_windows = kwargs['optimizationWindows']
- if preferred_life_cycle is None and 'preferredLifeCycle' in kwargs:
- preferred_life_cycle = kwargs['preferredLifeCycle']
- if revert_to_spot is None and 'revertToSpot' in kwargs:
- revert_to_spot = kwargs['revertToSpot']
-
- _setter("fallback_to_on_demand", fallback_to_on_demand)
+ pulumi.set(__self__, "fallback_to_on_demand", fallback_to_on_demand)
if capacity_reservations is not None:
- _setter("capacity_reservations", capacity_reservations)
+ pulumi.set(__self__, "capacity_reservations", capacity_reservations)
if draining_timeout is not None:
- _setter("draining_timeout", draining_timeout)
+ pulumi.set(__self__, "draining_timeout", draining_timeout)
if optimization_windows is not None:
- _setter("optimization_windows", optimization_windows)
+ pulumi.set(__self__, "optimization_windows", optimization_windows)
if preferred_life_cycle is not None:
- _setter("preferred_life_cycle", preferred_life_cycle)
+ pulumi.set(__self__, "preferred_life_cycle", preferred_life_cycle)
if revert_to_spot is not None:
- _setter("revert_to_spot", revert_to_spot)
+ pulumi.set(__self__, "revert_to_spot", revert_to_spot)
@property
@pulumi.getter(name="fallbackToOnDemand")
@@ -2971,35 +1944,10 @@ def __init__(__self__, *,
should_utilize: pulumi.Input[bool],
utilization_strategy: pulumi.Input[str],
capacity_reservation_groups: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureStrategyCapacityReservationCapacityReservationGroupArgs']]]] = None):
- StatefulNodeAzureStrategyCapacityReservationArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- should_utilize=should_utilize,
- utilization_strategy=utilization_strategy,
- capacity_reservation_groups=capacity_reservation_groups,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- should_utilize: Optional[pulumi.Input[bool]] = None,
- utilization_strategy: Optional[pulumi.Input[str]] = None,
- capacity_reservation_groups: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureStrategyCapacityReservationCapacityReservationGroupArgs']]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if should_utilize is None and 'shouldUtilize' in kwargs:
- should_utilize = kwargs['shouldUtilize']
- if should_utilize is None:
- raise TypeError("Missing 'should_utilize' argument")
- if utilization_strategy is None and 'utilizationStrategy' in kwargs:
- utilization_strategy = kwargs['utilizationStrategy']
- if utilization_strategy is None:
- raise TypeError("Missing 'utilization_strategy' argument")
- if capacity_reservation_groups is None and 'capacityReservationGroups' in kwargs:
- capacity_reservation_groups = kwargs['capacityReservationGroups']
-
- _setter("should_utilize", should_utilize)
- _setter("utilization_strategy", utilization_strategy)
+ pulumi.set(__self__, "should_utilize", should_utilize)
+ pulumi.set(__self__, "utilization_strategy", utilization_strategy)
if capacity_reservation_groups is not None:
- _setter("capacity_reservation_groups", capacity_reservation_groups)
+ pulumi.set(__self__, "capacity_reservation_groups", capacity_reservation_groups)
@property
@pulumi.getter(name="shouldUtilize")
@@ -3035,35 +1983,10 @@ def __init__(__self__, *,
crg_name: pulumi.Input[str],
crg_resource_group_name: pulumi.Input[str],
crg_should_prioritize: Optional[pulumi.Input[bool]] = None):
- StatefulNodeAzureStrategyCapacityReservationCapacityReservationGroupArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- crg_name=crg_name,
- crg_resource_group_name=crg_resource_group_name,
- crg_should_prioritize=crg_should_prioritize,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- crg_name: Optional[pulumi.Input[str]] = None,
- crg_resource_group_name: Optional[pulumi.Input[str]] = None,
- crg_should_prioritize: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if crg_name is None and 'crgName' in kwargs:
- crg_name = kwargs['crgName']
- if crg_name is None:
- raise TypeError("Missing 'crg_name' argument")
- if crg_resource_group_name is None and 'crgResourceGroupName' in kwargs:
- crg_resource_group_name = kwargs['crgResourceGroupName']
- if crg_resource_group_name is None:
- raise TypeError("Missing 'crg_resource_group_name' argument")
- if crg_should_prioritize is None and 'crgShouldPrioritize' in kwargs:
- crg_should_prioritize = kwargs['crgShouldPrioritize']
-
- _setter("crg_name", crg_name)
- _setter("crg_resource_group_name", crg_resource_group_name)
+ pulumi.set(__self__, "crg_name", crg_name)
+ pulumi.set(__self__, "crg_resource_group_name", crg_resource_group_name)
if crg_should_prioritize is not None:
- _setter("crg_should_prioritize", crg_should_prioritize)
+ pulumi.set(__self__, "crg_should_prioritize", crg_should_prioritize)
@property
@pulumi.getter(name="crgName")
@@ -3097,22 +2020,7 @@ def crg_should_prioritize(self, value: Optional[pulumi.Input[bool]]):
class StatefulNodeAzureStrategyRevertToSpotArgs:
def __init__(__self__, *,
perform_at: pulumi.Input[str]):
- StatefulNodeAzureStrategyRevertToSpotArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- perform_at=perform_at,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- perform_at: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if perform_at is None and 'performAt' in kwargs:
- perform_at = kwargs['performAt']
- if perform_at is None:
- raise TypeError("Missing 'perform_at' argument")
-
- _setter("perform_at", perform_at)
+ pulumi.set(__self__, "perform_at", perform_at)
@property
@pulumi.getter(name="performAt")
@@ -3129,28 +2037,9 @@ class StatefulNodeAzureTagArgs:
def __init__(__self__, *,
tag_key: pulumi.Input[str],
tag_value: Optional[pulumi.Input[str]] = None):
- StatefulNodeAzureTagArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- tag_key=tag_key,
- tag_value=tag_value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- tag_key: Optional[pulumi.Input[str]] = None,
- tag_value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if tag_key is None and 'tagKey' in kwargs:
- tag_key = kwargs['tagKey']
- if tag_key is None:
- raise TypeError("Missing 'tag_key' argument")
- if tag_value is None and 'tagValue' in kwargs:
- tag_value = kwargs['tagValue']
-
- _setter("tag_key", tag_key)
+ pulumi.set(__self__, "tag_key", tag_key)
if tag_value is not None:
- _setter("tag_value", tag_value)
+ pulumi.set(__self__, "tag_value", tag_value)
@property
@pulumi.getter(name="tagKey")
@@ -3175,20 +2064,7 @@ def tag_value(self, value: Optional[pulumi.Input[str]]):
class StatefulNodeAzureUpdateStateArgs:
def __init__(__self__, *,
state: pulumi.Input[str]):
- StatefulNodeAzureUpdateStateArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- state=state,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- state: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if state is None:
- raise TypeError("Missing 'state' argument")
-
- _setter("state", state)
+ pulumi.set(__self__, "state", state)
@property
@pulumi.getter
diff --git a/sdk/python/pulumi_spotinst/_utilities.py b/sdk/python/pulumi_spotinst/_utilities.py
index 2936b65a..2d9a3c84 100644
--- a/sdk/python/pulumi_spotinst/_utilities.py
+++ b/sdk/python/pulumi_spotinst/_utilities.py
@@ -246,24 +246,5 @@ def lifted_func(*args, opts=None, **kwargs):
return (lambda _: lifted_func)
-
-def configure(val, cls: type, input: bool):
- def _apply(v):
- if isinstance(v, typing.Mapping):
- def _setter(key, value):
- v[key] = value
- cls._configure(_setter, **v)
- return v
-
- # Check that cls has a static _configure method. External classes may
- # not have it if it was generated with older codegen.
- if hasattr(cls, "_configure"):
- if isinstance(val, typing.Mapping):
- return _apply(val)
- elif input and val is not None and not isinstance(val, cls):
- return pulumi.Output.from_input(val).apply(_apply)
-
- return val
-
def get_plugin_download_url():
return None
diff --git a/sdk/python/pulumi_spotinst/aws/_inputs.py b/sdk/python/pulumi_spotinst/aws/_inputs.py
index d0f8af8f..fef9c656 100644
--- a/sdk/python/pulumi_spotinst/aws/_inputs.py
+++ b/sdk/python/pulumi_spotinst/aws/_inputs.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
__all__ = [
@@ -181,37 +181,14 @@ def __init__(__self__, *,
:param pulumi.Input[int] grace_period: Amount of time to wait between batches
:param pulumi.Input[Sequence[pulumi.Input['BeanstalkDeploymentPreferencesStrategyArgs']]] strategies: Strategy parameters
"""
- BeanstalkDeploymentPreferencesArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- automatic_roll=automatic_roll,
- batch_size_percentage=batch_size_percentage,
- grace_period=grace_period,
- strategies=strategies,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- automatic_roll: Optional[pulumi.Input[bool]] = None,
- batch_size_percentage: Optional[pulumi.Input[int]] = None,
- grace_period: Optional[pulumi.Input[int]] = None,
- strategies: Optional[pulumi.Input[Sequence[pulumi.Input['BeanstalkDeploymentPreferencesStrategyArgs']]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if automatic_roll is None and 'automaticRoll' in kwargs:
- automatic_roll = kwargs['automaticRoll']
- if batch_size_percentage is None and 'batchSizePercentage' in kwargs:
- batch_size_percentage = kwargs['batchSizePercentage']
- if grace_period is None and 'gracePeriod' in kwargs:
- grace_period = kwargs['gracePeriod']
-
if automatic_roll is not None:
- _setter("automatic_roll", automatic_roll)
+ pulumi.set(__self__, "automatic_roll", automatic_roll)
if batch_size_percentage is not None:
- _setter("batch_size_percentage", batch_size_percentage)
+ pulumi.set(__self__, "batch_size_percentage", batch_size_percentage)
if grace_period is not None:
- _setter("grace_period", grace_period)
+ pulumi.set(__self__, "grace_period", grace_period)
if strategies is not None:
- _setter("strategies", strategies)
+ pulumi.set(__self__, "strategies", strategies)
@property
@pulumi.getter(name="automaticRoll")
@@ -271,25 +248,10 @@ def __init__(__self__, *,
:param pulumi.Input[str] action: Action to take
:param pulumi.Input[bool] should_drain_instances: Bool value if to wait to drain instance
"""
- BeanstalkDeploymentPreferencesStrategyArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- action=action,
- should_drain_instances=should_drain_instances,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- action: Optional[pulumi.Input[str]] = None,
- should_drain_instances: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if should_drain_instances is None and 'shouldDrainInstances' in kwargs:
- should_drain_instances = kwargs['shouldDrainInstances']
-
if action is not None:
- _setter("action", action)
+ pulumi.set(__self__, "action", action)
if should_drain_instances is not None:
- _setter("should_drain_instances", should_drain_instances)
+ pulumi.set(__self__, "should_drain_instances", should_drain_instances)
@property
@pulumi.getter
@@ -323,21 +285,8 @@ def __init__(__self__, *,
"""
:param pulumi.Input['BeanstalkManagedActionsPlatformUpdateArgs'] platform_update: Platform Update parameters
"""
- BeanstalkManagedActionsArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- platform_update=platform_update,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- platform_update: Optional[pulumi.Input['BeanstalkManagedActionsPlatformUpdateArgs']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if platform_update is None and 'platformUpdate' in kwargs:
- platform_update = kwargs['platformUpdate']
-
if platform_update is not None:
- _setter("platform_update", platform_update)
+ pulumi.set(__self__, "platform_update", platform_update)
@property
@pulumi.getter(name="platformUpdate")
@@ -363,33 +312,12 @@ def __init__(__self__, *,
:param pulumi.Input[str] time_window: Time Window for when action occurs ex. Mon:23:50-Tue:00:20
:param pulumi.Input[str] update_level: Level to update
"""
- BeanstalkManagedActionsPlatformUpdateArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- perform_at=perform_at,
- time_window=time_window,
- update_level=update_level,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- perform_at: Optional[pulumi.Input[str]] = None,
- time_window: Optional[pulumi.Input[str]] = None,
- update_level: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if perform_at is None and 'performAt' in kwargs:
- perform_at = kwargs['performAt']
- if time_window is None and 'timeWindow' in kwargs:
- time_window = kwargs['timeWindow']
- if update_level is None and 'updateLevel' in kwargs:
- update_level = kwargs['updateLevel']
-
if perform_at is not None:
- _setter("perform_at", perform_at)
+ pulumi.set(__self__, "perform_at", perform_at)
if time_window is not None:
- _setter("time_window", time_window)
+ pulumi.set(__self__, "time_window", time_window)
if update_level is not None:
- _setter("update_level", update_level)
+ pulumi.set(__self__, "update_level", update_level)
@property
@pulumi.getter(name="performAt")
@@ -469,102 +397,35 @@ def __init__(__self__, *,
:param pulumi.Input[str] start_time: Set a start time for one time tasks.
:param pulumi.Input[str] target_capacity: The desired number of instances the group should have.
"""
- BeanstalkScheduledTaskArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- task_type=task_type,
- adjustment=adjustment,
- adjustment_percentage=adjustment_percentage,
- batch_size_percentage=batch_size_percentage,
- cron_expression=cron_expression,
- frequency=frequency,
- grace_period=grace_period,
- is_enabled=is_enabled,
- max_capacity=max_capacity,
- min_capacity=min_capacity,
- scale_max_capacity=scale_max_capacity,
- scale_min_capacity=scale_min_capacity,
- scale_target_capacity=scale_target_capacity,
- start_time=start_time,
- target_capacity=target_capacity,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- task_type: Optional[pulumi.Input[str]] = None,
- adjustment: Optional[pulumi.Input[str]] = None,
- adjustment_percentage: Optional[pulumi.Input[str]] = None,
- batch_size_percentage: Optional[pulumi.Input[str]] = None,
- cron_expression: Optional[pulumi.Input[str]] = None,
- frequency: Optional[pulumi.Input[str]] = None,
- grace_period: Optional[pulumi.Input[str]] = None,
- is_enabled: Optional[pulumi.Input[bool]] = None,
- max_capacity: Optional[pulumi.Input[str]] = None,
- min_capacity: Optional[pulumi.Input[str]] = None,
- scale_max_capacity: Optional[pulumi.Input[str]] = None,
- scale_min_capacity: Optional[pulumi.Input[str]] = None,
- scale_target_capacity: Optional[pulumi.Input[str]] = None,
- start_time: Optional[pulumi.Input[str]] = None,
- target_capacity: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if task_type is None and 'taskType' in kwargs:
- task_type = kwargs['taskType']
- if task_type is None:
- raise TypeError("Missing 'task_type' argument")
- if adjustment_percentage is None and 'adjustmentPercentage' in kwargs:
- adjustment_percentage = kwargs['adjustmentPercentage']
- if batch_size_percentage is None and 'batchSizePercentage' in kwargs:
- batch_size_percentage = kwargs['batchSizePercentage']
- if cron_expression is None and 'cronExpression' in kwargs:
- cron_expression = kwargs['cronExpression']
- if grace_period is None and 'gracePeriod' in kwargs:
- grace_period = kwargs['gracePeriod']
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
- if max_capacity is None and 'maxCapacity' in kwargs:
- max_capacity = kwargs['maxCapacity']
- if min_capacity is None and 'minCapacity' in kwargs:
- min_capacity = kwargs['minCapacity']
- if scale_max_capacity is None and 'scaleMaxCapacity' in kwargs:
- scale_max_capacity = kwargs['scaleMaxCapacity']
- if scale_min_capacity is None and 'scaleMinCapacity' in kwargs:
- scale_min_capacity = kwargs['scaleMinCapacity']
- if scale_target_capacity is None and 'scaleTargetCapacity' in kwargs:
- scale_target_capacity = kwargs['scaleTargetCapacity']
- if start_time is None and 'startTime' in kwargs:
- start_time = kwargs['startTime']
- if target_capacity is None and 'targetCapacity' in kwargs:
- target_capacity = kwargs['targetCapacity']
-
- _setter("task_type", task_type)
+ pulumi.set(__self__, "task_type", task_type)
if adjustment is not None:
- _setter("adjustment", adjustment)
+ pulumi.set(__self__, "adjustment", adjustment)
if adjustment_percentage is not None:
- _setter("adjustment_percentage", adjustment_percentage)
+ pulumi.set(__self__, "adjustment_percentage", adjustment_percentage)
if batch_size_percentage is not None:
- _setter("batch_size_percentage", batch_size_percentage)
+ pulumi.set(__self__, "batch_size_percentage", batch_size_percentage)
if cron_expression is not None:
- _setter("cron_expression", cron_expression)
+ pulumi.set(__self__, "cron_expression", cron_expression)
if frequency is not None:
- _setter("frequency", frequency)
+ pulumi.set(__self__, "frequency", frequency)
if grace_period is not None:
- _setter("grace_period", grace_period)
+ pulumi.set(__self__, "grace_period", grace_period)
if is_enabled is not None:
- _setter("is_enabled", is_enabled)
+ pulumi.set(__self__, "is_enabled", is_enabled)
if max_capacity is not None:
- _setter("max_capacity", max_capacity)
+ pulumi.set(__self__, "max_capacity", max_capacity)
if min_capacity is not None:
- _setter("min_capacity", min_capacity)
+ pulumi.set(__self__, "min_capacity", min_capacity)
if scale_max_capacity is not None:
- _setter("scale_max_capacity", scale_max_capacity)
+ pulumi.set(__self__, "scale_max_capacity", scale_max_capacity)
if scale_min_capacity is not None:
- _setter("scale_min_capacity", scale_min_capacity)
+ pulumi.set(__self__, "scale_min_capacity", scale_min_capacity)
if scale_target_capacity is not None:
- _setter("scale_target_capacity", scale_target_capacity)
+ pulumi.set(__self__, "scale_target_capacity", scale_target_capacity)
if start_time is not None:
- _setter("start_time", start_time)
+ pulumi.set(__self__, "start_time", start_time)
if target_capacity is not None:
- _setter("target_capacity", target_capacity)
+ pulumi.set(__self__, "target_capacity", target_capacity)
@property
@pulumi.getter(name="taskType")
@@ -760,22 +621,7 @@ def __init__(__self__, *,
"""
:param pulumi.Input[int] threads_per_core: The ability to define the number of threads per core in instances that allow this.
"""
- ElastigroupCpuOptionsArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- threads_per_core=threads_per_core,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- threads_per_core: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if threads_per_core is None and 'threadsPerCore' in kwargs:
- threads_per_core = kwargs['threadsPerCore']
- if threads_per_core is None:
- raise TypeError("Missing 'threads_per_core' argument")
-
- _setter("threads_per_core", threads_per_core)
+ pulumi.set(__self__, "threads_per_core", threads_per_core)
@property
@pulumi.getter(name="threadsPerCore")
@@ -821,64 +667,23 @@ def __init__(__self__, *,
:param pulumi.Input[int] volume_size: The size of the volume in gigabytes.
:param pulumi.Input[str] volume_type: The type of volume. Can be `"standard"`, `"gp2"`, `"gp3"`, `"io1"`, `"st1"` or `"sc1"`.
"""
- ElastigroupEbsBlockDeviceArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- device_name=device_name,
- delete_on_termination=delete_on_termination,
- encrypted=encrypted,
- iops=iops,
- kms_key_id=kms_key_id,
- snapshot_id=snapshot_id,
- throughput=throughput,
- volume_size=volume_size,
- volume_type=volume_type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- device_name: Optional[pulumi.Input[str]] = None,
- delete_on_termination: Optional[pulumi.Input[bool]] = None,
- encrypted: Optional[pulumi.Input[bool]] = None,
- iops: Optional[pulumi.Input[int]] = None,
- kms_key_id: Optional[pulumi.Input[str]] = None,
- snapshot_id: Optional[pulumi.Input[str]] = None,
- throughput: Optional[pulumi.Input[int]] = None,
- volume_size: Optional[pulumi.Input[int]] = None,
- volume_type: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if device_name is None and 'deviceName' in kwargs:
- device_name = kwargs['deviceName']
- if device_name is None:
- raise TypeError("Missing 'device_name' argument")
- if delete_on_termination is None and 'deleteOnTermination' in kwargs:
- delete_on_termination = kwargs['deleteOnTermination']
- if kms_key_id is None and 'kmsKeyId' in kwargs:
- kms_key_id = kwargs['kmsKeyId']
- if snapshot_id is None and 'snapshotId' in kwargs:
- snapshot_id = kwargs['snapshotId']
- if volume_size is None and 'volumeSize' in kwargs:
- volume_size = kwargs['volumeSize']
- if volume_type is None and 'volumeType' in kwargs:
- volume_type = kwargs['volumeType']
-
- _setter("device_name", device_name)
+ pulumi.set(__self__, "device_name", device_name)
if delete_on_termination is not None:
- _setter("delete_on_termination", delete_on_termination)
+ pulumi.set(__self__, "delete_on_termination", delete_on_termination)
if encrypted is not None:
- _setter("encrypted", encrypted)
+ pulumi.set(__self__, "encrypted", encrypted)
if iops is not None:
- _setter("iops", iops)
+ pulumi.set(__self__, "iops", iops)
if kms_key_id is not None:
- _setter("kms_key_id", kms_key_id)
+ pulumi.set(__self__, "kms_key_id", kms_key_id)
if snapshot_id is not None:
- _setter("snapshot_id", snapshot_id)
+ pulumi.set(__self__, "snapshot_id", snapshot_id)
if throughput is not None:
- _setter("throughput", throughput)
+ pulumi.set(__self__, "throughput", throughput)
if volume_size is not None:
- _setter("volume_size", volume_size)
+ pulumi.set(__self__, "volume_size", volume_size)
if volume_type is not None:
- _setter("volume_type", volume_type)
+ pulumi.set(__self__, "volume_type", volume_type)
@property
@pulumi.getter(name="deviceName")
@@ -1013,29 +818,8 @@ def __init__(__self__, *,
import pulumi
```
"""
- ElastigroupEphemeralBlockDeviceArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- device_name=device_name,
- virtual_name=virtual_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- device_name: Optional[pulumi.Input[str]] = None,
- virtual_name: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if device_name is None and 'deviceName' in kwargs:
- device_name = kwargs['deviceName']
- if device_name is None:
- raise TypeError("Missing 'device_name' argument")
- if virtual_name is None and 'virtualName' in kwargs:
- virtual_name = kwargs['virtualName']
- if virtual_name is None:
- raise TypeError("Missing 'virtual_name' argument")
-
- _setter("device_name", device_name)
- _setter("virtual_name", virtual_name)
+ pulumi.set(__self__, "device_name", device_name)
+ pulumi.set(__self__, "virtual_name", virtual_name)
@property
@pulumi.getter(name="deviceName")
@@ -1073,20 +857,7 @@ def virtual_name(self, value: pulumi.Input[str]):
class ElastigroupImageArgs:
def __init__(__self__, *,
images: pulumi.Input[Sequence[pulumi.Input['ElastigroupImageImageArgs']]]):
- ElastigroupImageArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- images=images,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- images: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupImageImageArgs']]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if images is None:
- raise TypeError("Missing 'images' argument")
-
- _setter("images", images)
+ pulumi.set(__self__, "images", images)
@property
@pulumi.getter
@@ -1105,20 +876,7 @@ def __init__(__self__, *,
"""
:param pulumi.Input[str] id: The group ID.
"""
- ElastigroupImageImageArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- id=id,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- id: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if id is None:
- raise TypeError("Missing 'id' argument")
-
- _setter("id", id)
+ pulumi.set(__self__, "id", id)
@property
@pulumi.getter
@@ -1142,27 +900,8 @@ def __init__(__self__, *,
:param pulumi.Input[str] instance_type: Name of instance type (String).
:param pulumi.Input[int] weight: Weight per instance type (Integer).
"""
- ElastigroupInstanceTypesWeightArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- instance_type=instance_type,
- weight=weight,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- instance_type: Optional[pulumi.Input[str]] = None,
- weight: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if instance_type is None and 'instanceType' in kwargs:
- instance_type = kwargs['instanceType']
- if instance_type is None:
- raise TypeError("Missing 'instance_type' argument")
- if weight is None:
- raise TypeError("Missing 'weight' argument")
-
- _setter("instance_type", instance_type)
- _setter("weight", weight)
+ pulumi.set(__self__, "instance_type", instance_type)
+ pulumi.set(__self__, "weight", weight)
@property
@pulumi.getter(name="instanceType")
@@ -1199,33 +938,12 @@ def __init__(__self__, *,
:param pulumi.Input['ElastigroupIntegrationBeanstalkDeploymentPreferencesArgs'] deployment_preferences: Preferences when performing a roll
:param pulumi.Input['ElastigroupIntegrationBeanstalkManagedActionsArgs'] managed_actions: Managed Actions parameters
"""
- ElastigroupIntegrationBeanstalkArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- deployment_preferences=deployment_preferences,
- environment_id=environment_id,
- managed_actions=managed_actions,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- deployment_preferences: Optional[pulumi.Input['ElastigroupIntegrationBeanstalkDeploymentPreferencesArgs']] = None,
- environment_id: Optional[pulumi.Input[str]] = None,
- managed_actions: Optional[pulumi.Input['ElastigroupIntegrationBeanstalkManagedActionsArgs']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if deployment_preferences is None and 'deploymentPreferences' in kwargs:
- deployment_preferences = kwargs['deploymentPreferences']
- if environment_id is None and 'environmentId' in kwargs:
- environment_id = kwargs['environmentId']
- if managed_actions is None and 'managedActions' in kwargs:
- managed_actions = kwargs['managedActions']
-
if deployment_preferences is not None:
- _setter("deployment_preferences", deployment_preferences)
+ pulumi.set(__self__, "deployment_preferences", deployment_preferences)
if environment_id is not None:
- _setter("environment_id", environment_id)
+ pulumi.set(__self__, "environment_id", environment_id)
if managed_actions is not None:
- _setter("managed_actions", managed_actions)
+ pulumi.set(__self__, "managed_actions", managed_actions)
@property
@pulumi.getter(name="deploymentPreferences")
@@ -1274,37 +992,14 @@ def __init__(__self__, *,
:param pulumi.Input[int] grace_period: The period of time (seconds) to wait before checking a batch's health after it's deployment.
:param pulumi.Input['ElastigroupIntegrationBeanstalkDeploymentPreferencesStrategyArgs'] strategy: Strategy parameters
"""
- ElastigroupIntegrationBeanstalkDeploymentPreferencesArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- automatic_roll=automatic_roll,
- batch_size_percentage=batch_size_percentage,
- grace_period=grace_period,
- strategy=strategy,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- automatic_roll: Optional[pulumi.Input[bool]] = None,
- batch_size_percentage: Optional[pulumi.Input[int]] = None,
- grace_period: Optional[pulumi.Input[int]] = None,
- strategy: Optional[pulumi.Input['ElastigroupIntegrationBeanstalkDeploymentPreferencesStrategyArgs']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if automatic_roll is None and 'automaticRoll' in kwargs:
- automatic_roll = kwargs['automaticRoll']
- if batch_size_percentage is None and 'batchSizePercentage' in kwargs:
- batch_size_percentage = kwargs['batchSizePercentage']
- if grace_period is None and 'gracePeriod' in kwargs:
- grace_period = kwargs['gracePeriod']
-
if automatic_roll is not None:
- _setter("automatic_roll", automatic_roll)
+ pulumi.set(__self__, "automatic_roll", automatic_roll)
if batch_size_percentage is not None:
- _setter("batch_size_percentage", batch_size_percentage)
+ pulumi.set(__self__, "batch_size_percentage", batch_size_percentage)
if grace_period is not None:
- _setter("grace_period", grace_period)
+ pulumi.set(__self__, "grace_period", grace_period)
if strategy is not None:
- _setter("strategy", strategy)
+ pulumi.set(__self__, "strategy", strategy)
@property
@pulumi.getter(name="automaticRoll")
@@ -1364,25 +1059,10 @@ def __init__(__self__, *,
:param pulumi.Input[str] action: The action to take when scale up according to step's threshold is needed.
:param pulumi.Input[bool] should_drain_instances: Bool value if to wait to drain instance
"""
- ElastigroupIntegrationBeanstalkDeploymentPreferencesStrategyArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- action=action,
- should_drain_instances=should_drain_instances,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- action: Optional[pulumi.Input[str]] = None,
- should_drain_instances: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if should_drain_instances is None and 'shouldDrainInstances' in kwargs:
- should_drain_instances = kwargs['shouldDrainInstances']
-
if action is not None:
- _setter("action", action)
+ pulumi.set(__self__, "action", action)
if should_drain_instances is not None:
- _setter("should_drain_instances", should_drain_instances)
+ pulumi.set(__self__, "should_drain_instances", should_drain_instances)
@property
@pulumi.getter
@@ -1416,21 +1096,8 @@ def __init__(__self__, *,
"""
:param pulumi.Input['ElastigroupIntegrationBeanstalkManagedActionsPlatformUpdateArgs'] platform_update: Platform Update parameters
"""
- ElastigroupIntegrationBeanstalkManagedActionsArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- platform_update=platform_update,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- platform_update: Optional[pulumi.Input['ElastigroupIntegrationBeanstalkManagedActionsPlatformUpdateArgs']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if platform_update is None and 'platformUpdate' in kwargs:
- platform_update = kwargs['platformUpdate']
-
if platform_update is not None:
- _setter("platform_update", platform_update)
+ pulumi.set(__self__, "platform_update", platform_update)
@property
@pulumi.getter(name="platformUpdate")
@@ -1462,33 +1129,12 @@ def __init__(__self__, *,
import pulumi
```
"""
- ElastigroupIntegrationBeanstalkManagedActionsPlatformUpdateArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- perform_at=perform_at,
- time_window=time_window,
- update_level=update_level,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- perform_at: Optional[pulumi.Input[str]] = None,
- time_window: Optional[pulumi.Input[str]] = None,
- update_level: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if perform_at is None and 'performAt' in kwargs:
- perform_at = kwargs['performAt']
- if time_window is None and 'timeWindow' in kwargs:
- time_window = kwargs['timeWindow']
- if update_level is None and 'updateLevel' in kwargs:
- update_level = kwargs['updateLevel']
-
if perform_at is not None:
- _setter("perform_at", perform_at)
+ pulumi.set(__self__, "perform_at", perform_at)
if time_window is not None:
- _setter("time_window", time_window)
+ pulumi.set(__self__, "time_window", time_window)
if update_level is not None:
- _setter("update_level", update_level)
+ pulumi.set(__self__, "update_level", update_level)
@property
@pulumi.getter(name="performAt")
@@ -1544,36 +1190,9 @@ def __init__(__self__, *,
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupIntegrationCodedeployDeploymentGroupArgs']]] deployment_groups: Specify the deployment groups details.
:param pulumi.Input[bool] terminate_instance_on_failure: Terminate the instance automatically after a failed deploy.
"""
- ElastigroupIntegrationCodedeployArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cleanup_on_failure=cleanup_on_failure,
- deployment_groups=deployment_groups,
- terminate_instance_on_failure=terminate_instance_on_failure,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cleanup_on_failure: Optional[pulumi.Input[bool]] = None,
- deployment_groups: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupIntegrationCodedeployDeploymentGroupArgs']]]] = None,
- terminate_instance_on_failure: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cleanup_on_failure is None and 'cleanupOnFailure' in kwargs:
- cleanup_on_failure = kwargs['cleanupOnFailure']
- if cleanup_on_failure is None:
- raise TypeError("Missing 'cleanup_on_failure' argument")
- if deployment_groups is None and 'deploymentGroups' in kwargs:
- deployment_groups = kwargs['deploymentGroups']
- if deployment_groups is None:
- raise TypeError("Missing 'deployment_groups' argument")
- if terminate_instance_on_failure is None and 'terminateInstanceOnFailure' in kwargs:
- terminate_instance_on_failure = kwargs['terminateInstanceOnFailure']
- if terminate_instance_on_failure is None:
- raise TypeError("Missing 'terminate_instance_on_failure' argument")
-
- _setter("cleanup_on_failure", cleanup_on_failure)
- _setter("deployment_groups", deployment_groups)
- _setter("terminate_instance_on_failure", terminate_instance_on_failure)
+ pulumi.set(__self__, "cleanup_on_failure", cleanup_on_failure)
+ pulumi.set(__self__, "deployment_groups", deployment_groups)
+ pulumi.set(__self__, "terminate_instance_on_failure", terminate_instance_on_failure)
@property
@pulumi.getter(name="cleanupOnFailure")
@@ -1627,29 +1246,8 @@ def __init__(__self__, *,
import pulumi
```
"""
- ElastigroupIntegrationCodedeployDeploymentGroupArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- application_name=application_name,
- deployment_group_name=deployment_group_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- application_name: Optional[pulumi.Input[str]] = None,
- deployment_group_name: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if application_name is None and 'applicationName' in kwargs:
- application_name = kwargs['applicationName']
- if application_name is None:
- raise TypeError("Missing 'application_name' argument")
- if deployment_group_name is None and 'deploymentGroupName' in kwargs:
- deployment_group_name = kwargs['deploymentGroupName']
- if deployment_group_name is None:
- raise TypeError("Missing 'deployment_group_name' argument")
-
- _setter("application_name", application_name)
- _setter("deployment_group_name", deployment_group_name)
+ pulumi.set(__self__, "application_name", application_name)
+ pulumi.set(__self__, "deployment_group_name", deployment_group_name)
@property
@pulumi.getter(name="applicationName")
@@ -1699,53 +1297,16 @@ def __init__(__self__, *,
:param pulumi.Input['ElastigroupIntegrationDockerSwarmAutoscaleHeadroomArgs'] autoscale_headroom: An option to set compute reserve for the cluster.
:param pulumi.Input[bool] autoscale_is_enabled: Specifies whether the auto scaling feature is enabled.
"""
- ElastigroupIntegrationDockerSwarmArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- master_host=master_host,
- master_port=master_port,
- autoscale_cooldown=autoscale_cooldown,
- autoscale_down=autoscale_down,
- autoscale_headroom=autoscale_headroom,
- autoscale_is_enabled=autoscale_is_enabled,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- master_host: Optional[pulumi.Input[str]] = None,
- master_port: Optional[pulumi.Input[int]] = None,
- autoscale_cooldown: Optional[pulumi.Input[int]] = None,
- autoscale_down: Optional[pulumi.Input['ElastigroupIntegrationDockerSwarmAutoscaleDownArgs']] = None,
- autoscale_headroom: Optional[pulumi.Input['ElastigroupIntegrationDockerSwarmAutoscaleHeadroomArgs']] = None,
- autoscale_is_enabled: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if master_host is None and 'masterHost' in kwargs:
- master_host = kwargs['masterHost']
- if master_host is None:
- raise TypeError("Missing 'master_host' argument")
- if master_port is None and 'masterPort' in kwargs:
- master_port = kwargs['masterPort']
- if master_port is None:
- raise TypeError("Missing 'master_port' argument")
- if autoscale_cooldown is None and 'autoscaleCooldown' in kwargs:
- autoscale_cooldown = kwargs['autoscaleCooldown']
- if autoscale_down is None and 'autoscaleDown' in kwargs:
- autoscale_down = kwargs['autoscaleDown']
- if autoscale_headroom is None and 'autoscaleHeadroom' in kwargs:
- autoscale_headroom = kwargs['autoscaleHeadroom']
- if autoscale_is_enabled is None and 'autoscaleIsEnabled' in kwargs:
- autoscale_is_enabled = kwargs['autoscaleIsEnabled']
-
- _setter("master_host", master_host)
- _setter("master_port", master_port)
+ pulumi.set(__self__, "master_host", master_host)
+ pulumi.set(__self__, "master_port", master_port)
if autoscale_cooldown is not None:
- _setter("autoscale_cooldown", autoscale_cooldown)
+ pulumi.set(__self__, "autoscale_cooldown", autoscale_cooldown)
if autoscale_down is not None:
- _setter("autoscale_down", autoscale_down)
+ pulumi.set(__self__, "autoscale_down", autoscale_down)
if autoscale_headroom is not None:
- _setter("autoscale_headroom", autoscale_headroom)
+ pulumi.set(__self__, "autoscale_headroom", autoscale_headroom)
if autoscale_is_enabled is not None:
- _setter("autoscale_is_enabled", autoscale_is_enabled)
+ pulumi.set(__self__, "autoscale_is_enabled", autoscale_is_enabled)
@property
@pulumi.getter(name="masterHost")
@@ -1829,27 +1390,10 @@ def __init__(__self__, *,
:param pulumi.Input[int] evaluation_periods: The number of periods over which data is compared to the specified threshold.
:param pulumi.Input[float] max_scale_down_percentage: Represents the maximum percent to scale-down. Number between 1-100.
"""
- ElastigroupIntegrationDockerSwarmAutoscaleDownArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- evaluation_periods=evaluation_periods,
- max_scale_down_percentage=max_scale_down_percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- evaluation_periods: Optional[pulumi.Input[int]] = None,
- max_scale_down_percentage: Optional[pulumi.Input[float]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
- if max_scale_down_percentage is None and 'maxScaleDownPercentage' in kwargs:
- max_scale_down_percentage = kwargs['maxScaleDownPercentage']
-
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
if max_scale_down_percentage is not None:
- _setter("max_scale_down_percentage", max_scale_down_percentage)
+ pulumi.set(__self__, "max_scale_down_percentage", max_scale_down_percentage)
@property
@pulumi.getter(name="evaluationPeriods")
@@ -1887,33 +1431,12 @@ def __init__(__self__, *,
:param pulumi.Input[int] memory_per_unit: How much Memory allocate for headroom unit.
:param pulumi.Input[int] num_of_units: How many units of headroom to allocate.
"""
- ElastigroupIntegrationDockerSwarmAutoscaleHeadroomArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cpu_per_unit=cpu_per_unit,
- memory_per_unit=memory_per_unit,
- num_of_units=num_of_units,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cpu_per_unit: Optional[pulumi.Input[int]] = None,
- memory_per_unit: Optional[pulumi.Input[int]] = None,
- num_of_units: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cpu_per_unit is None and 'cpuPerUnit' in kwargs:
- cpu_per_unit = kwargs['cpuPerUnit']
- if memory_per_unit is None and 'memoryPerUnit' in kwargs:
- memory_per_unit = kwargs['memoryPerUnit']
- if num_of_units is None and 'numOfUnits' in kwargs:
- num_of_units = kwargs['numOfUnits']
-
if cpu_per_unit is not None:
- _setter("cpu_per_unit", cpu_per_unit)
+ pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
if memory_per_unit is not None:
- _setter("memory_per_unit", memory_per_unit)
+ pulumi.set(__self__, "memory_per_unit", memory_per_unit)
if num_of_units is not None:
- _setter("num_of_units", num_of_units)
+ pulumi.set(__self__, "num_of_units", num_of_units)
@property
@pulumi.getter(name="cpuPerUnit")
@@ -1975,68 +1498,23 @@ def __init__(__self__, *,
:param pulumi.Input[bool] autoscale_scale_down_non_service_tasks: Determines whether to scale down non-service tasks.
:param pulumi.Input['ElastigroupIntegrationEcsBatchArgs'] batch: Batch configuration object:
"""
- ElastigroupIntegrationEcsArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cluster_name=cluster_name,
- autoscale_attributes=autoscale_attributes,
- autoscale_cooldown=autoscale_cooldown,
- autoscale_down=autoscale_down,
- autoscale_headroom=autoscale_headroom,
- autoscale_is_auto_config=autoscale_is_auto_config,
- autoscale_is_enabled=autoscale_is_enabled,
- autoscale_scale_down_non_service_tasks=autoscale_scale_down_non_service_tasks,
- batch=batch,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cluster_name: Optional[pulumi.Input[str]] = None,
- autoscale_attributes: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupIntegrationEcsAutoscaleAttributeArgs']]]] = None,
- autoscale_cooldown: Optional[pulumi.Input[int]] = None,
- autoscale_down: Optional[pulumi.Input['ElastigroupIntegrationEcsAutoscaleDownArgs']] = None,
- autoscale_headroom: Optional[pulumi.Input['ElastigroupIntegrationEcsAutoscaleHeadroomArgs']] = None,
- autoscale_is_auto_config: Optional[pulumi.Input[bool]] = None,
- autoscale_is_enabled: Optional[pulumi.Input[bool]] = None,
- autoscale_scale_down_non_service_tasks: Optional[pulumi.Input[bool]] = None,
- batch: Optional[pulumi.Input['ElastigroupIntegrationEcsBatchArgs']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cluster_name is None and 'clusterName' in kwargs:
- cluster_name = kwargs['clusterName']
- if cluster_name is None:
- raise TypeError("Missing 'cluster_name' argument")
- if autoscale_attributes is None and 'autoscaleAttributes' in kwargs:
- autoscale_attributes = kwargs['autoscaleAttributes']
- if autoscale_cooldown is None and 'autoscaleCooldown' in kwargs:
- autoscale_cooldown = kwargs['autoscaleCooldown']
- if autoscale_down is None and 'autoscaleDown' in kwargs:
- autoscale_down = kwargs['autoscaleDown']
- if autoscale_headroom is None and 'autoscaleHeadroom' in kwargs:
- autoscale_headroom = kwargs['autoscaleHeadroom']
- if autoscale_is_auto_config is None and 'autoscaleIsAutoConfig' in kwargs:
- autoscale_is_auto_config = kwargs['autoscaleIsAutoConfig']
- if autoscale_is_enabled is None and 'autoscaleIsEnabled' in kwargs:
- autoscale_is_enabled = kwargs['autoscaleIsEnabled']
- if autoscale_scale_down_non_service_tasks is None and 'autoscaleScaleDownNonServiceTasks' in kwargs:
- autoscale_scale_down_non_service_tasks = kwargs['autoscaleScaleDownNonServiceTasks']
-
- _setter("cluster_name", cluster_name)
+ pulumi.set(__self__, "cluster_name", cluster_name)
if autoscale_attributes is not None:
- _setter("autoscale_attributes", autoscale_attributes)
+ pulumi.set(__self__, "autoscale_attributes", autoscale_attributes)
if autoscale_cooldown is not None:
- _setter("autoscale_cooldown", autoscale_cooldown)
+ pulumi.set(__self__, "autoscale_cooldown", autoscale_cooldown)
if autoscale_down is not None:
- _setter("autoscale_down", autoscale_down)
+ pulumi.set(__self__, "autoscale_down", autoscale_down)
if autoscale_headroom is not None:
- _setter("autoscale_headroom", autoscale_headroom)
+ pulumi.set(__self__, "autoscale_headroom", autoscale_headroom)
if autoscale_is_auto_config is not None:
- _setter("autoscale_is_auto_config", autoscale_is_auto_config)
+ pulumi.set(__self__, "autoscale_is_auto_config", autoscale_is_auto_config)
if autoscale_is_enabled is not None:
- _setter("autoscale_is_enabled", autoscale_is_enabled)
+ pulumi.set(__self__, "autoscale_is_enabled", autoscale_is_enabled)
if autoscale_scale_down_non_service_tasks is not None:
- _setter("autoscale_scale_down_non_service_tasks", autoscale_scale_down_non_service_tasks)
+ pulumi.set(__self__, "autoscale_scale_down_non_service_tasks", autoscale_scale_down_non_service_tasks)
if batch is not None:
- _setter("batch", batch)
+ pulumi.set(__self__, "batch", batch)
@property
@pulumi.getter(name="clusterName")
@@ -2155,25 +1633,8 @@ def __init__(__self__, *,
"""
:param pulumi.Input[str] value: The dimension value.
"""
- ElastigroupIntegrationEcsAutoscaleAttributeArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -2206,27 +1667,10 @@ def __init__(__self__, *,
:param pulumi.Input[int] evaluation_periods: The number of periods over which data is compared to the specified threshold.
:param pulumi.Input[float] max_scale_down_percentage: Represents the maximum percent to scale-down. Number between 1-100.
"""
- ElastigroupIntegrationEcsAutoscaleDownArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- evaluation_periods=evaluation_periods,
- max_scale_down_percentage=max_scale_down_percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- evaluation_periods: Optional[pulumi.Input[int]] = None,
- max_scale_down_percentage: Optional[pulumi.Input[float]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
- if max_scale_down_percentage is None and 'maxScaleDownPercentage' in kwargs:
- max_scale_down_percentage = kwargs['maxScaleDownPercentage']
-
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
if max_scale_down_percentage is not None:
- _setter("max_scale_down_percentage", max_scale_down_percentage)
+ pulumi.set(__self__, "max_scale_down_percentage", max_scale_down_percentage)
@property
@pulumi.getter(name="evaluationPeriods")
@@ -2264,33 +1708,12 @@ def __init__(__self__, *,
:param pulumi.Input[int] memory_per_unit: How much Memory allocate for headroom unit.
:param pulumi.Input[int] num_of_units: How many units of headroom to allocate.
"""
- ElastigroupIntegrationEcsAutoscaleHeadroomArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cpu_per_unit=cpu_per_unit,
- memory_per_unit=memory_per_unit,
- num_of_units=num_of_units,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cpu_per_unit: Optional[pulumi.Input[int]] = None,
- memory_per_unit: Optional[pulumi.Input[int]] = None,
- num_of_units: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cpu_per_unit is None and 'cpuPerUnit' in kwargs:
- cpu_per_unit = kwargs['cpuPerUnit']
- if memory_per_unit is None and 'memoryPerUnit' in kwargs:
- memory_per_unit = kwargs['memoryPerUnit']
- if num_of_units is None and 'numOfUnits' in kwargs:
- num_of_units = kwargs['numOfUnits']
-
if cpu_per_unit is not None:
- _setter("cpu_per_unit", cpu_per_unit)
+ pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
if memory_per_unit is not None:
- _setter("memory_per_unit", memory_per_unit)
+ pulumi.set(__self__, "memory_per_unit", memory_per_unit)
if num_of_units is not None:
- _setter("num_of_units", num_of_units)
+ pulumi.set(__self__, "num_of_units", num_of_units)
@property
@pulumi.getter(name="cpuPerUnit")
@@ -2342,22 +1765,7 @@ def __init__(__self__, *,
import pulumi
```
"""
- ElastigroupIntegrationEcsBatchArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- job_queue_names=job_queue_names,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- job_queue_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if job_queue_names is None and 'jobQueueNames' in kwargs:
- job_queue_names = kwargs['jobQueueNames']
- if job_queue_names is None:
- raise TypeError("Missing 'job_queue_names' argument")
-
- _setter("job_queue_names", job_queue_names)
+ pulumi.set(__self__, "job_queue_names", job_queue_names)
@property
@pulumi.getter(name="jobQueueNames")
@@ -2385,19 +1793,8 @@ def __init__(__self__, *,
"""
:param pulumi.Input['ElastigroupIntegrationGitlabRunnerArgs'] runner: Settings for Gitlab runner.
"""
- ElastigroupIntegrationGitlabArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- runner=runner,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- runner: Optional[pulumi.Input['ElastigroupIntegrationGitlabRunnerArgs']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if runner is not None:
- _setter("runner", runner)
+ pulumi.set(__self__, "runner", runner)
@property
@pulumi.getter
@@ -2419,21 +1816,8 @@ def __init__(__self__, *,
"""
:param pulumi.Input[bool] is_enabled: Specifies whether the scaling policy described in this block is enabled.
"""
- ElastigroupIntegrationGitlabRunnerArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- is_enabled=is_enabled,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- is_enabled: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
-
if is_enabled is not None:
- _setter("is_enabled", is_enabled)
+ pulumi.set(__self__, "is_enabled", is_enabled)
@property
@pulumi.getter(name="isEnabled")
@@ -2484,73 +1868,26 @@ def __init__(__self__, *,
:param pulumi.Input[str] integration_mode: Valid values: `"saas"`, `"pod"`.
:param pulumi.Input[str] token: Kubernetes Token
"""
- ElastigroupIntegrationKubernetesArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- api_server=api_server,
- autoscale_cooldown=autoscale_cooldown,
- autoscale_down=autoscale_down,
- autoscale_headroom=autoscale_headroom,
- autoscale_is_auto_config=autoscale_is_auto_config,
- autoscale_is_enabled=autoscale_is_enabled,
- autoscale_labels=autoscale_labels,
- cluster_identifier=cluster_identifier,
- integration_mode=integration_mode,
- token=token,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- api_server: Optional[pulumi.Input[str]] = None,
- autoscale_cooldown: Optional[pulumi.Input[int]] = None,
- autoscale_down: Optional[pulumi.Input['ElastigroupIntegrationKubernetesAutoscaleDownArgs']] = None,
- autoscale_headroom: Optional[pulumi.Input['ElastigroupIntegrationKubernetesAutoscaleHeadroomArgs']] = None,
- autoscale_is_auto_config: Optional[pulumi.Input[bool]] = None,
- autoscale_is_enabled: Optional[pulumi.Input[bool]] = None,
- autoscale_labels: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupIntegrationKubernetesAutoscaleLabelArgs']]]] = None,
- cluster_identifier: Optional[pulumi.Input[str]] = None,
- integration_mode: Optional[pulumi.Input[str]] = None,
- token: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if api_server is None and 'apiServer' in kwargs:
- api_server = kwargs['apiServer']
- if autoscale_cooldown is None and 'autoscaleCooldown' in kwargs:
- autoscale_cooldown = kwargs['autoscaleCooldown']
- if autoscale_down is None and 'autoscaleDown' in kwargs:
- autoscale_down = kwargs['autoscaleDown']
- if autoscale_headroom is None and 'autoscaleHeadroom' in kwargs:
- autoscale_headroom = kwargs['autoscaleHeadroom']
- if autoscale_is_auto_config is None and 'autoscaleIsAutoConfig' in kwargs:
- autoscale_is_auto_config = kwargs['autoscaleIsAutoConfig']
- if autoscale_is_enabled is None and 'autoscaleIsEnabled' in kwargs:
- autoscale_is_enabled = kwargs['autoscaleIsEnabled']
- if autoscale_labels is None and 'autoscaleLabels' in kwargs:
- autoscale_labels = kwargs['autoscaleLabels']
- if cluster_identifier is None and 'clusterIdentifier' in kwargs:
- cluster_identifier = kwargs['clusterIdentifier']
- if integration_mode is None and 'integrationMode' in kwargs:
- integration_mode = kwargs['integrationMode']
-
if api_server is not None:
- _setter("api_server", api_server)
+ pulumi.set(__self__, "api_server", api_server)
if autoscale_cooldown is not None:
- _setter("autoscale_cooldown", autoscale_cooldown)
+ pulumi.set(__self__, "autoscale_cooldown", autoscale_cooldown)
if autoscale_down is not None:
- _setter("autoscale_down", autoscale_down)
+ pulumi.set(__self__, "autoscale_down", autoscale_down)
if autoscale_headroom is not None:
- _setter("autoscale_headroom", autoscale_headroom)
+ pulumi.set(__self__, "autoscale_headroom", autoscale_headroom)
if autoscale_is_auto_config is not None:
- _setter("autoscale_is_auto_config", autoscale_is_auto_config)
+ pulumi.set(__self__, "autoscale_is_auto_config", autoscale_is_auto_config)
if autoscale_is_enabled is not None:
- _setter("autoscale_is_enabled", autoscale_is_enabled)
+ pulumi.set(__self__, "autoscale_is_enabled", autoscale_is_enabled)
if autoscale_labels is not None:
- _setter("autoscale_labels", autoscale_labels)
+ pulumi.set(__self__, "autoscale_labels", autoscale_labels)
if cluster_identifier is not None:
- _setter("cluster_identifier", cluster_identifier)
+ pulumi.set(__self__, "cluster_identifier", cluster_identifier)
if integration_mode is not None:
- _setter("integration_mode", integration_mode)
+ pulumi.set(__self__, "integration_mode", integration_mode)
if token is not None:
- _setter("token", token)
+ pulumi.set(__self__, "token", token)
@property
@pulumi.getter(name="apiServer")
@@ -2691,27 +2028,10 @@ def __init__(__self__, *,
:param pulumi.Input[int] evaluation_periods: The number of periods over which data is compared to the specified threshold.
:param pulumi.Input[float] max_scale_down_percentage: Represents the maximum percent to scale-down. Number between 1-100.
"""
- ElastigroupIntegrationKubernetesAutoscaleDownArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- evaluation_periods=evaluation_periods,
- max_scale_down_percentage=max_scale_down_percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- evaluation_periods: Optional[pulumi.Input[int]] = None,
- max_scale_down_percentage: Optional[pulumi.Input[float]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
- if max_scale_down_percentage is None and 'maxScaleDownPercentage' in kwargs:
- max_scale_down_percentage = kwargs['maxScaleDownPercentage']
-
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
if max_scale_down_percentage is not None:
- _setter("max_scale_down_percentage", max_scale_down_percentage)
+ pulumi.set(__self__, "max_scale_down_percentage", max_scale_down_percentage)
@property
@pulumi.getter(name="evaluationPeriods")
@@ -2749,33 +2069,12 @@ def __init__(__self__, *,
:param pulumi.Input[int] memory_per_unit: How much Memory allocate for headroom unit.
:param pulumi.Input[int] num_of_units: How many units of headroom to allocate.
"""
- ElastigroupIntegrationKubernetesAutoscaleHeadroomArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cpu_per_unit=cpu_per_unit,
- memory_per_unit=memory_per_unit,
- num_of_units=num_of_units,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cpu_per_unit: Optional[pulumi.Input[int]] = None,
- memory_per_unit: Optional[pulumi.Input[int]] = None,
- num_of_units: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cpu_per_unit is None and 'cpuPerUnit' in kwargs:
- cpu_per_unit = kwargs['cpuPerUnit']
- if memory_per_unit is None and 'memoryPerUnit' in kwargs:
- memory_per_unit = kwargs['memoryPerUnit']
- if num_of_units is None and 'numOfUnits' in kwargs:
- num_of_units = kwargs['numOfUnits']
-
if cpu_per_unit is not None:
- _setter("cpu_per_unit", cpu_per_unit)
+ pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
if memory_per_unit is not None:
- _setter("memory_per_unit", memory_per_unit)
+ pulumi.set(__self__, "memory_per_unit", memory_per_unit)
if num_of_units is not None:
- _setter("num_of_units", num_of_units)
+ pulumi.set(__self__, "num_of_units", num_of_units)
@property
@pulumi.getter(name="cpuPerUnit")
@@ -2822,25 +2121,8 @@ def __init__(__self__, *,
"""
:param pulumi.Input[str] value: The dimension value.
"""
- ElastigroupIntegrationKubernetesAutoscaleLabelArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -2877,22 +2159,7 @@ def __init__(__self__, *,
import pulumi
```
"""
- ElastigroupIntegrationMesosphereArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- api_server=api_server,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- api_server: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if api_server is None and 'apiServer' in kwargs:
- api_server = kwargs['apiServer']
- if api_server is None:
- raise TypeError("Missing 'api_server' argument")
-
- _setter("api_server", api_server)
+ pulumi.set(__self__, "api_server", api_server)
@property
@pulumi.getter(name="apiServer")
@@ -2926,22 +2193,7 @@ def __init__(__self__, *,
import pulumi
```
"""
- ElastigroupIntegrationMultaiRuntimeArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- deployment_id=deployment_id,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- deployment_id: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if deployment_id is None and 'deploymentId' in kwargs:
- deployment_id = kwargs['deploymentId']
- if deployment_id is None:
- raise TypeError("Missing 'deployment_id' argument")
-
- _setter("deployment_id", deployment_id)
+ pulumi.set(__self__, "deployment_id", deployment_id)
@property
@pulumi.getter(name="deploymentId")
@@ -2989,65 +2241,20 @@ def __init__(__self__, *,
:param pulumi.Input['ElastigroupIntegrationNomadAutoscaleHeadroomArgs'] autoscale_headroom: An option to set compute reserve for the cluster.
:param pulumi.Input[bool] autoscale_is_enabled: Specifies whether the auto scaling feature is enabled.
"""
- ElastigroupIntegrationNomadArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- master_host=master_host,
- master_port=master_port,
- acl_token=acl_token,
- autoscale_constraints=autoscale_constraints,
- autoscale_cooldown=autoscale_cooldown,
- autoscale_down=autoscale_down,
- autoscale_headroom=autoscale_headroom,
- autoscale_is_enabled=autoscale_is_enabled,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- master_host: Optional[pulumi.Input[str]] = None,
- master_port: Optional[pulumi.Input[int]] = None,
- acl_token: Optional[pulumi.Input[str]] = None,
- autoscale_constraints: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupIntegrationNomadAutoscaleConstraintArgs']]]] = None,
- autoscale_cooldown: Optional[pulumi.Input[int]] = None,
- autoscale_down: Optional[pulumi.Input['ElastigroupIntegrationNomadAutoscaleDownArgs']] = None,
- autoscale_headroom: Optional[pulumi.Input['ElastigroupIntegrationNomadAutoscaleHeadroomArgs']] = None,
- autoscale_is_enabled: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if master_host is None and 'masterHost' in kwargs:
- master_host = kwargs['masterHost']
- if master_host is None:
- raise TypeError("Missing 'master_host' argument")
- if master_port is None and 'masterPort' in kwargs:
- master_port = kwargs['masterPort']
- if master_port is None:
- raise TypeError("Missing 'master_port' argument")
- if acl_token is None and 'aclToken' in kwargs:
- acl_token = kwargs['aclToken']
- if autoscale_constraints is None and 'autoscaleConstraints' in kwargs:
- autoscale_constraints = kwargs['autoscaleConstraints']
- if autoscale_cooldown is None and 'autoscaleCooldown' in kwargs:
- autoscale_cooldown = kwargs['autoscaleCooldown']
- if autoscale_down is None and 'autoscaleDown' in kwargs:
- autoscale_down = kwargs['autoscaleDown']
- if autoscale_headroom is None and 'autoscaleHeadroom' in kwargs:
- autoscale_headroom = kwargs['autoscaleHeadroom']
- if autoscale_is_enabled is None and 'autoscaleIsEnabled' in kwargs:
- autoscale_is_enabled = kwargs['autoscaleIsEnabled']
-
- _setter("master_host", master_host)
- _setter("master_port", master_port)
+ pulumi.set(__self__, "master_host", master_host)
+ pulumi.set(__self__, "master_port", master_port)
if acl_token is not None:
- _setter("acl_token", acl_token)
+ pulumi.set(__self__, "acl_token", acl_token)
if autoscale_constraints is not None:
- _setter("autoscale_constraints", autoscale_constraints)
+ pulumi.set(__self__, "autoscale_constraints", autoscale_constraints)
if autoscale_cooldown is not None:
- _setter("autoscale_cooldown", autoscale_cooldown)
+ pulumi.set(__self__, "autoscale_cooldown", autoscale_cooldown)
if autoscale_down is not None:
- _setter("autoscale_down", autoscale_down)
+ pulumi.set(__self__, "autoscale_down", autoscale_down)
if autoscale_headroom is not None:
- _setter("autoscale_headroom", autoscale_headroom)
+ pulumi.set(__self__, "autoscale_headroom", autoscale_headroom)
if autoscale_is_enabled is not None:
- _setter("autoscale_is_enabled", autoscale_is_enabled)
+ pulumi.set(__self__, "autoscale_is_enabled", autoscale_is_enabled)
@property
@pulumi.getter(name="masterHost")
@@ -3160,25 +2367,8 @@ def __init__(__self__, *,
"""
:param pulumi.Input[str] value: The dimension value.
"""
- ElastigroupIntegrationNomadAutoscaleConstraintArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -3209,21 +2399,8 @@ def __init__(__self__, *,
"""
:param pulumi.Input[int] evaluation_periods: The number of periods over which data is compared to the specified threshold.
"""
- ElastigroupIntegrationNomadAutoscaleDownArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- evaluation_periods=evaluation_periods,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- evaluation_periods: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
-
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
@property
@pulumi.getter(name="evaluationPeriods")
@@ -3249,33 +2426,12 @@ def __init__(__self__, *,
:param pulumi.Input[int] memory_per_unit: How much Memory allocate for headroom unit.
:param pulumi.Input[int] num_of_units: How many units of headroom to allocate.
"""
- ElastigroupIntegrationNomadAutoscaleHeadroomArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cpu_per_unit=cpu_per_unit,
- memory_per_unit=memory_per_unit,
- num_of_units=num_of_units,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cpu_per_unit: Optional[pulumi.Input[int]] = None,
- memory_per_unit: Optional[pulumi.Input[int]] = None,
- num_of_units: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cpu_per_unit is None and 'cpuPerUnit' in kwargs:
- cpu_per_unit = kwargs['cpuPerUnit']
- if memory_per_unit is None and 'memoryPerUnit' in kwargs:
- memory_per_unit = kwargs['memoryPerUnit']
- if num_of_units is None and 'numOfUnits' in kwargs:
- num_of_units = kwargs['numOfUnits']
-
if cpu_per_unit is not None:
- _setter("cpu_per_unit", cpu_per_unit)
+ pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
if memory_per_unit is not None:
- _setter("memory_per_unit", memory_per_unit)
+ pulumi.set(__self__, "memory_per_unit", memory_per_unit)
if num_of_units is not None:
- _setter("num_of_units", num_of_units)
+ pulumi.set(__self__, "num_of_units", num_of_units)
@property
@pulumi.getter(name="cpuPerUnit")
@@ -3332,40 +2488,11 @@ def __init__(__self__, *,
import pulumi
```
"""
- ElastigroupIntegrationRancherArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- access_key=access_key,
- master_host=master_host,
- secret_key=secret_key,
- version=version,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- access_key: Optional[pulumi.Input[str]] = None,
- master_host: Optional[pulumi.Input[str]] = None,
- secret_key: Optional[pulumi.Input[str]] = None,
- version: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if access_key is None and 'accessKey' in kwargs:
- access_key = kwargs['accessKey']
- if access_key is None:
- raise TypeError("Missing 'access_key' argument")
- if master_host is None and 'masterHost' in kwargs:
- master_host = kwargs['masterHost']
- if master_host is None:
- raise TypeError("Missing 'master_host' argument")
- if secret_key is None and 'secretKey' in kwargs:
- secret_key = kwargs['secretKey']
- if secret_key is None:
- raise TypeError("Missing 'secret_key' argument")
-
- _setter("access_key", access_key)
- _setter("master_host", master_host)
- _setter("secret_key", secret_key)
+ pulumi.set(__self__, "access_key", access_key)
+ pulumi.set(__self__, "master_host", master_host)
+ pulumi.set(__self__, "secret_key", secret_key)
if version is not None:
- _setter("version", version)
+ pulumi.set(__self__, "version", version)
@property
@pulumi.getter(name="accessKey")
@@ -3428,20 +2555,7 @@ def __init__(__self__, *,
"""
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupIntegrationRoute53DomainArgs']]] domains: Collection of one or more domains to register.
"""
- ElastigroupIntegrationRoute53Args._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- domains=domains,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- domains: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupIntegrationRoute53DomainArgs']]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if domains is None:
- raise TypeError("Missing 'domains' argument")
-
- _setter("domains", domains)
+ pulumi.set(__self__, "domains", domains)
@property
@pulumi.getter
@@ -3469,41 +2583,12 @@ def __init__(__self__, *,
:param pulumi.Input[str] record_set_type: The type of the record set. Valid values: `"a"`, `"cname"`.
:param pulumi.Input[str] spotinst_acct_id: The Spotinst account ID that is linked to the AWS account that holds the Route 53 Hosted Zone ID. The default is the user Spotinst account provided as a URL parameter.
"""
- ElastigroupIntegrationRoute53DomainArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- hosted_zone_id=hosted_zone_id,
- record_sets=record_sets,
- record_set_type=record_set_type,
- spotinst_acct_id=spotinst_acct_id,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- hosted_zone_id: Optional[pulumi.Input[str]] = None,
- record_sets: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupIntegrationRoute53DomainRecordSetArgs']]]] = None,
- record_set_type: Optional[pulumi.Input[str]] = None,
- spotinst_acct_id: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if hosted_zone_id is None and 'hostedZoneId' in kwargs:
- hosted_zone_id = kwargs['hostedZoneId']
- if hosted_zone_id is None:
- raise TypeError("Missing 'hosted_zone_id' argument")
- if record_sets is None and 'recordSets' in kwargs:
- record_sets = kwargs['recordSets']
- if record_sets is None:
- raise TypeError("Missing 'record_sets' argument")
- if record_set_type is None and 'recordSetType' in kwargs:
- record_set_type = kwargs['recordSetType']
- if spotinst_acct_id is None and 'spotinstAcctId' in kwargs:
- spotinst_acct_id = kwargs['spotinstAcctId']
-
- _setter("hosted_zone_id", hosted_zone_id)
- _setter("record_sets", record_sets)
+ pulumi.set(__self__, "hosted_zone_id", hosted_zone_id)
+ pulumi.set(__self__, "record_sets", record_sets)
if record_set_type is not None:
- _setter("record_set_type", record_set_type)
+ pulumi.set(__self__, "record_set_type", record_set_type)
if spotinst_acct_id is not None:
- _setter("spotinst_acct_id", spotinst_acct_id)
+ pulumi.set(__self__, "spotinst_acct_id", spotinst_acct_id)
@property
@pulumi.getter(name="hostedZoneId")
@@ -3571,32 +2656,11 @@ def __init__(__self__, *,
```
:param pulumi.Input[bool] use_public_ip: Designates whether the IP address should be exposed to connections outside the VPC.
"""
- ElastigroupIntegrationRoute53DomainRecordSetArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- use_public_dns=use_public_dns,
- use_public_ip=use_public_ip,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- use_public_dns: Optional[pulumi.Input[bool]] = None,
- use_public_ip: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
- if use_public_dns is None and 'usePublicDns' in kwargs:
- use_public_dns = kwargs['usePublicDns']
- if use_public_ip is None and 'usePublicIp' in kwargs:
- use_public_ip = kwargs['usePublicIp']
-
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if use_public_dns is not None:
- _setter("use_public_dns", use_public_dns)
+ pulumi.set(__self__, "use_public_dns", use_public_dns)
if use_public_ip is not None:
- _setter("use_public_ip", use_public_ip)
+ pulumi.set(__self__, "use_public_ip", use_public_ip)
@property
@pulumi.getter
@@ -3650,55 +2714,14 @@ def __init__(__self__, *,
weight_strategy: pulumi.Input[str],
default_static_target_group: Optional[pulumi.Input['ElastigroupItfDefaultStaticTargetGroupArgs']] = None,
migration_healthiness_threshold: Optional[pulumi.Input[int]] = None):
- ElastigroupItfArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- fixed_target_groups=fixed_target_groups,
- load_balancers=load_balancers,
- target_group_configs=target_group_configs,
- weight_strategy=weight_strategy,
- default_static_target_group=default_static_target_group,
- migration_healthiness_threshold=migration_healthiness_threshold,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- fixed_target_groups: Optional[pulumi.Input[bool]] = None,
- load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupItfLoadBalancerArgs']]]] = None,
- target_group_configs: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupItfTargetGroupConfigArgs']]]] = None,
- weight_strategy: Optional[pulumi.Input[str]] = None,
- default_static_target_group: Optional[pulumi.Input['ElastigroupItfDefaultStaticTargetGroupArgs']] = None,
- migration_healthiness_threshold: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if fixed_target_groups is None and 'fixedTargetGroups' in kwargs:
- fixed_target_groups = kwargs['fixedTargetGroups']
- if fixed_target_groups is None:
- raise TypeError("Missing 'fixed_target_groups' argument")
- if load_balancers is None and 'loadBalancers' in kwargs:
- load_balancers = kwargs['loadBalancers']
- if load_balancers is None:
- raise TypeError("Missing 'load_balancers' argument")
- if target_group_configs is None and 'targetGroupConfigs' in kwargs:
- target_group_configs = kwargs['targetGroupConfigs']
- if target_group_configs is None:
- raise TypeError("Missing 'target_group_configs' argument")
- if weight_strategy is None and 'weightStrategy' in kwargs:
- weight_strategy = kwargs['weightStrategy']
- if weight_strategy is None:
- raise TypeError("Missing 'weight_strategy' argument")
- if default_static_target_group is None and 'defaultStaticTargetGroup' in kwargs:
- default_static_target_group = kwargs['defaultStaticTargetGroup']
- if migration_healthiness_threshold is None and 'migrationHealthinessThreshold' in kwargs:
- migration_healthiness_threshold = kwargs['migrationHealthinessThreshold']
-
- _setter("fixed_target_groups", fixed_target_groups)
- _setter("load_balancers", load_balancers)
- _setter("target_group_configs", target_group_configs)
- _setter("weight_strategy", weight_strategy)
+ pulumi.set(__self__, "fixed_target_groups", fixed_target_groups)
+ pulumi.set(__self__, "load_balancers", load_balancers)
+ pulumi.set(__self__, "target_group_configs", target_group_configs)
+ pulumi.set(__self__, "weight_strategy", weight_strategy)
if default_static_target_group is not None:
- _setter("default_static_target_group", default_static_target_group)
+ pulumi.set(__self__, "default_static_target_group", default_static_target_group)
if migration_healthiness_threshold is not None:
- _setter("migration_healthiness_threshold", migration_healthiness_threshold)
+ pulumi.set(__self__, "migration_healthiness_threshold", migration_healthiness_threshold)
@property
@pulumi.getter(name="fixedTargetGroups")
@@ -3760,25 +2783,8 @@ class ElastigroupItfDefaultStaticTargetGroupArgs:
def __init__(__self__, *,
arn: pulumi.Input[str],
percentage: pulumi.Input[float]):
- ElastigroupItfDefaultStaticTargetGroupArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- arn=arn,
- percentage=percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- arn: Optional[pulumi.Input[str]] = None,
- percentage: Optional[pulumi.Input[float]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if arn is None:
- raise TypeError("Missing 'arn' argument")
- if percentage is None:
- raise TypeError("Missing 'percentage' argument")
-
- _setter("arn", arn)
- _setter("percentage", percentage)
+ pulumi.set(__self__, "arn", arn)
+ pulumi.set(__self__, "percentage", percentage)
@property
@pulumi.getter
@@ -3804,29 +2810,8 @@ class ElastigroupItfLoadBalancerArgs:
def __init__(__self__, *,
listener_rules: pulumi.Input[Sequence[pulumi.Input['ElastigroupItfLoadBalancerListenerRuleArgs']]],
load_balancer_arn: pulumi.Input[str]):
- ElastigroupItfLoadBalancerArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- listener_rules=listener_rules,
- load_balancer_arn=load_balancer_arn,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- listener_rules: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupItfLoadBalancerListenerRuleArgs']]]] = None,
- load_balancer_arn: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if listener_rules is None and 'listenerRules' in kwargs:
- listener_rules = kwargs['listenerRules']
- if listener_rules is None:
- raise TypeError("Missing 'listener_rules' argument")
- if load_balancer_arn is None and 'loadBalancerArn' in kwargs:
- load_balancer_arn = kwargs['loadBalancerArn']
- if load_balancer_arn is None:
- raise TypeError("Missing 'load_balancer_arn' argument")
-
- _setter("listener_rules", listener_rules)
- _setter("load_balancer_arn", load_balancer_arn)
+ pulumi.set(__self__, "listener_rules", listener_rules)
+ pulumi.set(__self__, "load_balancer_arn", load_balancer_arn)
@property
@pulumi.getter(name="listenerRules")
@@ -3852,28 +2837,9 @@ class ElastigroupItfLoadBalancerListenerRuleArgs:
def __init__(__self__, *,
rule_arn: pulumi.Input[str],
static_target_group: Optional[pulumi.Input['ElastigroupItfLoadBalancerListenerRuleStaticTargetGroupArgs']] = None):
- ElastigroupItfLoadBalancerListenerRuleArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- rule_arn=rule_arn,
- static_target_group=static_target_group,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- rule_arn: Optional[pulumi.Input[str]] = None,
- static_target_group: Optional[pulumi.Input['ElastigroupItfLoadBalancerListenerRuleStaticTargetGroupArgs']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if rule_arn is None and 'ruleArn' in kwargs:
- rule_arn = kwargs['ruleArn']
- if rule_arn is None:
- raise TypeError("Missing 'rule_arn' argument")
- if static_target_group is None and 'staticTargetGroup' in kwargs:
- static_target_group = kwargs['staticTargetGroup']
-
- _setter("rule_arn", rule_arn)
+ pulumi.set(__self__, "rule_arn", rule_arn)
if static_target_group is not None:
- _setter("static_target_group", static_target_group)
+ pulumi.set(__self__, "static_target_group", static_target_group)
@property
@pulumi.getter(name="ruleArn")
@@ -3899,25 +2865,8 @@ class ElastigroupItfLoadBalancerListenerRuleStaticTargetGroupArgs:
def __init__(__self__, *,
arn: pulumi.Input[str],
percentage: pulumi.Input[float]):
- ElastigroupItfLoadBalancerListenerRuleStaticTargetGroupArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- arn=arn,
- percentage=percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- arn: Optional[pulumi.Input[str]] = None,
- percentage: Optional[pulumi.Input[float]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if arn is None:
- raise TypeError("Missing 'arn' argument")
- if percentage is None:
- raise TypeError("Missing 'percentage' argument")
-
- _setter("arn", arn)
- _setter("percentage", percentage)
+ pulumi.set(__self__, "arn", arn)
+ pulumi.set(__self__, "percentage", percentage)
@property
@pulumi.getter
@@ -3957,89 +2906,28 @@ def __init__(__self__, *,
"""
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupItfTargetGroupConfigTagArgs']]] tags: A key/value mapping of tags to assign to the resource.
"""
- ElastigroupItfTargetGroupConfigArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- health_check_path=health_check_path,
- port=port,
- protocol=protocol,
- vpc_id=vpc_id,
- health_check_interval_seconds=health_check_interval_seconds,
- health_check_port=health_check_port,
- health_check_protocol=health_check_protocol,
- health_check_timeout_seconds=health_check_timeout_seconds,
- healthy_threshold_count=healthy_threshold_count,
- matchers=matchers,
- protocol_version=protocol_version,
- tags=tags,
- unhealthy_threshold_count=unhealthy_threshold_count,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- health_check_path: Optional[pulumi.Input[str]] = None,
- port: Optional[pulumi.Input[int]] = None,
- protocol: Optional[pulumi.Input[str]] = None,
- vpc_id: Optional[pulumi.Input[str]] = None,
- health_check_interval_seconds: Optional[pulumi.Input[int]] = None,
- health_check_port: Optional[pulumi.Input[str]] = None,
- health_check_protocol: Optional[pulumi.Input[str]] = None,
- health_check_timeout_seconds: Optional[pulumi.Input[int]] = None,
- healthy_threshold_count: Optional[pulumi.Input[int]] = None,
- matchers: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupItfTargetGroupConfigMatcherArgs']]]] = None,
- protocol_version: Optional[pulumi.Input[str]] = None,
- tags: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupItfTargetGroupConfigTagArgs']]]] = None,
- unhealthy_threshold_count: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if health_check_path is None and 'healthCheckPath' in kwargs:
- health_check_path = kwargs['healthCheckPath']
- if health_check_path is None:
- raise TypeError("Missing 'health_check_path' argument")
- if port is None:
- raise TypeError("Missing 'port' argument")
- if protocol is None:
- raise TypeError("Missing 'protocol' argument")
- if vpc_id is None and 'vpcId' in kwargs:
- vpc_id = kwargs['vpcId']
- if vpc_id is None:
- raise TypeError("Missing 'vpc_id' argument")
- if health_check_interval_seconds is None and 'healthCheckIntervalSeconds' in kwargs:
- health_check_interval_seconds = kwargs['healthCheckIntervalSeconds']
- if health_check_port is None and 'healthCheckPort' in kwargs:
- health_check_port = kwargs['healthCheckPort']
- if health_check_protocol is None and 'healthCheckProtocol' in kwargs:
- health_check_protocol = kwargs['healthCheckProtocol']
- if health_check_timeout_seconds is None and 'healthCheckTimeoutSeconds' in kwargs:
- health_check_timeout_seconds = kwargs['healthCheckTimeoutSeconds']
- if healthy_threshold_count is None and 'healthyThresholdCount' in kwargs:
- healthy_threshold_count = kwargs['healthyThresholdCount']
- if protocol_version is None and 'protocolVersion' in kwargs:
- protocol_version = kwargs['protocolVersion']
- if unhealthy_threshold_count is None and 'unhealthyThresholdCount' in kwargs:
- unhealthy_threshold_count = kwargs['unhealthyThresholdCount']
-
- _setter("health_check_path", health_check_path)
- _setter("port", port)
- _setter("protocol", protocol)
- _setter("vpc_id", vpc_id)
+ pulumi.set(__self__, "health_check_path", health_check_path)
+ pulumi.set(__self__, "port", port)
+ pulumi.set(__self__, "protocol", protocol)
+ pulumi.set(__self__, "vpc_id", vpc_id)
if health_check_interval_seconds is not None:
- _setter("health_check_interval_seconds", health_check_interval_seconds)
+ pulumi.set(__self__, "health_check_interval_seconds", health_check_interval_seconds)
if health_check_port is not None:
- _setter("health_check_port", health_check_port)
+ pulumi.set(__self__, "health_check_port", health_check_port)
if health_check_protocol is not None:
- _setter("health_check_protocol", health_check_protocol)
+ pulumi.set(__self__, "health_check_protocol", health_check_protocol)
if health_check_timeout_seconds is not None:
- _setter("health_check_timeout_seconds", health_check_timeout_seconds)
+ pulumi.set(__self__, "health_check_timeout_seconds", health_check_timeout_seconds)
if healthy_threshold_count is not None:
- _setter("healthy_threshold_count", healthy_threshold_count)
+ pulumi.set(__self__, "healthy_threshold_count", healthy_threshold_count)
if matchers is not None:
- _setter("matchers", matchers)
+ pulumi.set(__self__, "matchers", matchers)
if protocol_version is not None:
- _setter("protocol_version", protocol_version)
+ pulumi.set(__self__, "protocol_version", protocol_version)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
if unhealthy_threshold_count is not None:
- _setter("unhealthy_threshold_count", unhealthy_threshold_count)
+ pulumi.set(__self__, "unhealthy_threshold_count", unhealthy_threshold_count)
@property
@pulumi.getter(name="healthCheckPath")
@@ -4167,27 +3055,10 @@ class ElastigroupItfTargetGroupConfigMatcherArgs:
def __init__(__self__, *,
grpc_code: Optional[pulumi.Input[str]] = None,
http_code: Optional[pulumi.Input[str]] = None):
- ElastigroupItfTargetGroupConfigMatcherArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- grpc_code=grpc_code,
- http_code=http_code,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- grpc_code: Optional[pulumi.Input[str]] = None,
- http_code: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if grpc_code is None and 'grpcCode' in kwargs:
- grpc_code = kwargs['grpcCode']
- if http_code is None and 'httpCode' in kwargs:
- http_code = kwargs['httpCode']
-
if grpc_code is not None:
- _setter("grpc_code", grpc_code)
+ pulumi.set(__self__, "grpc_code", grpc_code)
if http_code is not None:
- _setter("http_code", http_code)
+ pulumi.set(__self__, "http_code", http_code)
@property
@pulumi.getter(name="grpcCode")
@@ -4213,28 +3084,9 @@ class ElastigroupItfTargetGroupConfigTagArgs:
def __init__(__self__, *,
tag_key: pulumi.Input[str],
tag_value: Optional[pulumi.Input[str]] = None):
- ElastigroupItfTargetGroupConfigTagArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- tag_key=tag_key,
- tag_value=tag_value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- tag_key: Optional[pulumi.Input[str]] = None,
- tag_value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if tag_key is None and 'tagKey' in kwargs:
- tag_key = kwargs['tagKey']
- if tag_key is None:
- raise TypeError("Missing 'tag_key' argument")
- if tag_value is None and 'tagValue' in kwargs:
- tag_value = kwargs['tagValue']
-
- _setter("tag_key", tag_key)
+ pulumi.set(__self__, "tag_key", tag_key)
if tag_value is not None:
- _setter("tag_value", tag_value)
+ pulumi.set(__self__, "tag_value", tag_value)
@property
@pulumi.getter(name="tagKey")
@@ -4266,34 +3118,11 @@ def __init__(__self__, *,
:param pulumi.Input[int] http_put_response_hop_limit: The desired HTTP PUT response hop limit for instance metadata requests. The larger the number, the further instance metadata requests can travel. Valid values: Integers from `1` to `64`.
:param pulumi.Input[str] instance_metadata_tags: Indicates whether access to instance tags from the instance metadata is enabled or disabled. Can’t be null.
"""
- ElastigroupMetadataOptionsArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- http_tokens=http_tokens,
- http_put_response_hop_limit=http_put_response_hop_limit,
- instance_metadata_tags=instance_metadata_tags,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- http_tokens: Optional[pulumi.Input[str]] = None,
- http_put_response_hop_limit: Optional[pulumi.Input[int]] = None,
- instance_metadata_tags: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if http_tokens is None and 'httpTokens' in kwargs:
- http_tokens = kwargs['httpTokens']
- if http_tokens is None:
- raise TypeError("Missing 'http_tokens' argument")
- if http_put_response_hop_limit is None and 'httpPutResponseHopLimit' in kwargs:
- http_put_response_hop_limit = kwargs['httpPutResponseHopLimit']
- if instance_metadata_tags is None and 'instanceMetadataTags' in kwargs:
- instance_metadata_tags = kwargs['instanceMetadataTags']
-
- _setter("http_tokens", http_tokens)
+ pulumi.set(__self__, "http_tokens", http_tokens)
if http_put_response_hop_limit is not None:
- _setter("http_put_response_hop_limit", http_put_response_hop_limit)
+ pulumi.set(__self__, "http_put_response_hop_limit", http_put_response_hop_limit)
if instance_metadata_tags is not None:
- _setter("instance_metadata_tags", instance_metadata_tags)
+ pulumi.set(__self__, "instance_metadata_tags", instance_metadata_tags)
@property
@pulumi.getter(name="httpTokens")
@@ -4347,29 +3176,8 @@ def __init__(__self__, *,
```
:param pulumi.Input[str] target_set_id: ID of Multai target set.
"""
- ElastigroupMultaiTargetSetArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- balancer_id=balancer_id,
- target_set_id=target_set_id,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- balancer_id: Optional[pulumi.Input[str]] = None,
- target_set_id: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if balancer_id is None and 'balancerId' in kwargs:
- balancer_id = kwargs['balancerId']
- if balancer_id is None:
- raise TypeError("Missing 'balancer_id' argument")
- if target_set_id is None and 'targetSetId' in kwargs:
- target_set_id = kwargs['targetSetId']
- if target_set_id is None:
- raise TypeError("Missing 'target_set_id' argument")
-
- _setter("balancer_id", balancer_id)
- _setter("target_set_id", target_set_id)
+ pulumi.set(__self__, "balancer_id", balancer_id)
+ pulumi.set(__self__, "target_set_id", target_set_id)
@property
@pulumi.getter(name="balancerId")
@@ -4411,23 +3219,10 @@ def __init__(__self__, *,
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupMultipleMetricsExpressionArgs']]] expressions: Array of objects (Expression config)
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupMultipleMetricsMetricArgs']]] metrics: Array of objects (Metric config)
"""
- ElastigroupMultipleMetricsArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- expressions=expressions,
- metrics=metrics,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- expressions: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupMultipleMetricsExpressionArgs']]]] = None,
- metrics: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupMultipleMetricsMetricArgs']]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if expressions is not None:
- _setter("expressions", expressions)
+ pulumi.set(__self__, "expressions", expressions)
if metrics is not None:
- _setter("metrics", metrics)
+ pulumi.set(__self__, "metrics", metrics)
@property
@pulumi.getter
@@ -4463,25 +3258,8 @@ def __init__(__self__, *,
:param pulumi.Input[str] expression: An expression consisting of the metric names listed in the 'metrics' array.
:param pulumi.Input[str] name: The group name.
"""
- ElastigroupMultipleMetricsExpressionArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- expression=expression,
- name=name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- expression: Optional[pulumi.Input[str]] = None,
- name: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if expression is None:
- raise TypeError("Missing 'expression' argument")
- if name is None:
- raise TypeError("Missing 'name' argument")
-
- _setter("expression", expression)
- _setter("name", name)
+ pulumi.set(__self__, "expression", expression)
+ pulumi.set(__self__, "name", name)
@property
@pulumi.getter
@@ -4527,50 +3305,17 @@ def __init__(__self__, *,
:param pulumi.Input[str] statistic: The metric statistics to return. For information about specific statistics go to [Statistics](http://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/index.html?CHAP_TerminologyandKeyConcepts.html#Statistic) in the Amazon CloudWatch Developer Guide.
:param pulumi.Input[str] unit: The unit for the alarm's associated metric. Valid values: `"percent`, `"seconds"`, `"microseconds"`, `"milliseconds"`, `"bytes"`, `"kilobytes"`, `"megabytes"`, `"gigabytes"`, `"terabytes"`, `"bits"`, `"kilobits"`, `"megabits"`, `"gigabits"`, `"terabits"`, `"count"`, `"bytes/second"`, `"kilobytes/second"`, `"megabytes/second"`, `"gigabytes/second"`, `"terabytes/second"`, `"bits/second"`, `"kilobits/second"`, `"megabits/second"`, `"gigabits/second"`, `"terabits/second"`, `"count/second"`, `"none"`.
"""
- ElastigroupMultipleMetricsMetricArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- metric_name=metric_name,
- name=name,
- namespace=namespace,
- dimensions=dimensions,
- extended_statistic=extended_statistic,
- statistic=statistic,
- unit=unit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- metric_name: Optional[pulumi.Input[str]] = None,
- name: Optional[pulumi.Input[str]] = None,
- namespace: Optional[pulumi.Input[str]] = None,
- dimensions: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupMultipleMetricsMetricDimensionArgs']]]] = None,
- extended_statistic: Optional[pulumi.Input[str]] = None,
- statistic: Optional[pulumi.Input[str]] = None,
- unit: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if metric_name is None and 'metricName' in kwargs:
- metric_name = kwargs['metricName']
- if metric_name is None:
- raise TypeError("Missing 'metric_name' argument")
- if name is None:
- raise TypeError("Missing 'name' argument")
- if namespace is None:
- raise TypeError("Missing 'namespace' argument")
- if extended_statistic is None and 'extendedStatistic' in kwargs:
- extended_statistic = kwargs['extendedStatistic']
-
- _setter("metric_name", metric_name)
- _setter("name", name)
- _setter("namespace", namespace)
+ pulumi.set(__self__, "metric_name", metric_name)
+ pulumi.set(__self__, "name", name)
+ pulumi.set(__self__, "namespace", namespace)
if dimensions is not None:
- _setter("dimensions", dimensions)
+ pulumi.set(__self__, "dimensions", dimensions)
if extended_statistic is not None:
- _setter("extended_statistic", extended_statistic)
+ pulumi.set(__self__, "extended_statistic", extended_statistic)
if statistic is not None:
- _setter("statistic", statistic)
+ pulumi.set(__self__, "statistic", statistic)
if unit is not None:
- _setter("unit", unit)
+ pulumi.set(__self__, "unit", unit)
@property
@pulumi.getter(name="metricName")
@@ -4666,24 +3411,9 @@ def __init__(__self__, *,
:param pulumi.Input[str] name: The group name.
:param pulumi.Input[str] value: The dimension value.
"""
- ElastigroupMultipleMetricsMetricDimensionArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
-
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if value is not None:
- _setter("value", value)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -4737,62 +3467,21 @@ def __init__(__self__, *,
:param pulumi.Input[str] private_ip_address: The private IP address of the network interface.
:param pulumi.Input[str] secondary_private_ip_address_count: The number of secondary private IP addresses.
"""
- ElastigroupNetworkInterfaceArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- device_index=device_index,
- associate_ipv6_address=associate_ipv6_address,
- associate_public_ip_address=associate_public_ip_address,
- delete_on_termination=delete_on_termination,
- description=description,
- network_interface_id=network_interface_id,
- private_ip_address=private_ip_address,
- secondary_private_ip_address_count=secondary_private_ip_address_count,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- device_index: Optional[pulumi.Input[str]] = None,
- associate_ipv6_address: Optional[pulumi.Input[bool]] = None,
- associate_public_ip_address: Optional[pulumi.Input[bool]] = None,
- delete_on_termination: Optional[pulumi.Input[bool]] = None,
- description: Optional[pulumi.Input[str]] = None,
- network_interface_id: Optional[pulumi.Input[str]] = None,
- private_ip_address: Optional[pulumi.Input[str]] = None,
- secondary_private_ip_address_count: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if device_index is None and 'deviceIndex' in kwargs:
- device_index = kwargs['deviceIndex']
- if device_index is None:
- raise TypeError("Missing 'device_index' argument")
- if associate_ipv6_address is None and 'associateIpv6Address' in kwargs:
- associate_ipv6_address = kwargs['associateIpv6Address']
- if associate_public_ip_address is None and 'associatePublicIpAddress' in kwargs:
- associate_public_ip_address = kwargs['associatePublicIpAddress']
- if delete_on_termination is None and 'deleteOnTermination' in kwargs:
- delete_on_termination = kwargs['deleteOnTermination']
- if network_interface_id is None and 'networkInterfaceId' in kwargs:
- network_interface_id = kwargs['networkInterfaceId']
- if private_ip_address is None and 'privateIpAddress' in kwargs:
- private_ip_address = kwargs['privateIpAddress']
- if secondary_private_ip_address_count is None and 'secondaryPrivateIpAddressCount' in kwargs:
- secondary_private_ip_address_count = kwargs['secondaryPrivateIpAddressCount']
-
- _setter("device_index", device_index)
+ pulumi.set(__self__, "device_index", device_index)
if associate_ipv6_address is not None:
- _setter("associate_ipv6_address", associate_ipv6_address)
+ pulumi.set(__self__, "associate_ipv6_address", associate_ipv6_address)
if associate_public_ip_address is not None:
- _setter("associate_public_ip_address", associate_public_ip_address)
+ pulumi.set(__self__, "associate_public_ip_address", associate_public_ip_address)
if delete_on_termination is not None:
- _setter("delete_on_termination", delete_on_termination)
+ pulumi.set(__self__, "delete_on_termination", delete_on_termination)
if description is not None:
- _setter("description", description)
+ pulumi.set(__self__, "description", description)
if network_interface_id is not None:
- _setter("network_interface_id", network_interface_id)
+ pulumi.set(__self__, "network_interface_id", network_interface_id)
if private_ip_address is not None:
- _setter("private_ip_address", private_ip_address)
+ pulumi.set(__self__, "private_ip_address", private_ip_address)
if secondary_private_ip_address_count is not None:
- _setter("secondary_private_ip_address_count", secondary_private_ip_address_count)
+ pulumi.set(__self__, "secondary_private_ip_address_count", secondary_private_ip_address_count)
@property
@pulumi.getter(name="deviceIndex")
@@ -4920,73 +3609,20 @@ def __init__(__self__, *,
:param pulumi.Input[int] required_gpu_maximum: Required maximum instance GPU (<=16)
:param pulumi.Input[int] required_gpu_minimum: Required minimum instance GPU (>=1)
"""
- ElastigroupResourceRequirementArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- required_memory_maximum=required_memory_maximum,
- required_memory_minimum=required_memory_minimum,
- required_vcpu_maximum=required_vcpu_maximum,
- required_vcpu_minimum=required_vcpu_minimum,
- excluded_instance_families=excluded_instance_families,
- excluded_instance_generations=excluded_instance_generations,
- excluded_instance_types=excluded_instance_types,
- required_gpu_maximum=required_gpu_maximum,
- required_gpu_minimum=required_gpu_minimum,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- required_memory_maximum: Optional[pulumi.Input[int]] = None,
- required_memory_minimum: Optional[pulumi.Input[int]] = None,
- required_vcpu_maximum: Optional[pulumi.Input[int]] = None,
- required_vcpu_minimum: Optional[pulumi.Input[int]] = None,
- excluded_instance_families: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- excluded_instance_generations: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- excluded_instance_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- required_gpu_maximum: Optional[pulumi.Input[int]] = None,
- required_gpu_minimum: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if required_memory_maximum is None and 'requiredMemoryMaximum' in kwargs:
- required_memory_maximum = kwargs['requiredMemoryMaximum']
- if required_memory_maximum is None:
- raise TypeError("Missing 'required_memory_maximum' argument")
- if required_memory_minimum is None and 'requiredMemoryMinimum' in kwargs:
- required_memory_minimum = kwargs['requiredMemoryMinimum']
- if required_memory_minimum is None:
- raise TypeError("Missing 'required_memory_minimum' argument")
- if required_vcpu_maximum is None and 'requiredVcpuMaximum' in kwargs:
- required_vcpu_maximum = kwargs['requiredVcpuMaximum']
- if required_vcpu_maximum is None:
- raise TypeError("Missing 'required_vcpu_maximum' argument")
- if required_vcpu_minimum is None and 'requiredVcpuMinimum' in kwargs:
- required_vcpu_minimum = kwargs['requiredVcpuMinimum']
- if required_vcpu_minimum is None:
- raise TypeError("Missing 'required_vcpu_minimum' argument")
- if excluded_instance_families is None and 'excludedInstanceFamilies' in kwargs:
- excluded_instance_families = kwargs['excludedInstanceFamilies']
- if excluded_instance_generations is None and 'excludedInstanceGenerations' in kwargs:
- excluded_instance_generations = kwargs['excludedInstanceGenerations']
- if excluded_instance_types is None and 'excludedInstanceTypes' in kwargs:
- excluded_instance_types = kwargs['excludedInstanceTypes']
- if required_gpu_maximum is None and 'requiredGpuMaximum' in kwargs:
- required_gpu_maximum = kwargs['requiredGpuMaximum']
- if required_gpu_minimum is None and 'requiredGpuMinimum' in kwargs:
- required_gpu_minimum = kwargs['requiredGpuMinimum']
-
- _setter("required_memory_maximum", required_memory_maximum)
- _setter("required_memory_minimum", required_memory_minimum)
- _setter("required_vcpu_maximum", required_vcpu_maximum)
- _setter("required_vcpu_minimum", required_vcpu_minimum)
+ pulumi.set(__self__, "required_memory_maximum", required_memory_maximum)
+ pulumi.set(__self__, "required_memory_minimum", required_memory_minimum)
+ pulumi.set(__self__, "required_vcpu_maximum", required_vcpu_maximum)
+ pulumi.set(__self__, "required_vcpu_minimum", required_vcpu_minimum)
if excluded_instance_families is not None:
- _setter("excluded_instance_families", excluded_instance_families)
+ pulumi.set(__self__, "excluded_instance_families", excluded_instance_families)
if excluded_instance_generations is not None:
- _setter("excluded_instance_generations", excluded_instance_generations)
+ pulumi.set(__self__, "excluded_instance_generations", excluded_instance_generations)
if excluded_instance_types is not None:
- _setter("excluded_instance_types", excluded_instance_types)
+ pulumi.set(__self__, "excluded_instance_types", excluded_instance_types)
if required_gpu_maximum is not None:
- _setter("required_gpu_maximum", required_gpu_maximum)
+ pulumi.set(__self__, "required_gpu_maximum", required_gpu_maximum)
if required_gpu_minimum is not None:
- _setter("required_gpu_minimum", required_gpu_minimum)
+ pulumi.set(__self__, "required_gpu_minimum", required_gpu_minimum)
@property
@pulumi.getter(name="requiredMemoryMaximum")
@@ -5110,39 +3746,14 @@ def __init__(__self__, *,
:param pulumi.Input[bool] should_tag_snapshots: Tag specification for Snapshot resources.
:param pulumi.Input[bool] should_tag_volumes: Tag specification for Volume resources.
"""
- ElastigroupResourceTagSpecificationArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- should_tag_amis=should_tag_amis,
- should_tag_enis=should_tag_enis,
- should_tag_snapshots=should_tag_snapshots,
- should_tag_volumes=should_tag_volumes,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- should_tag_amis: Optional[pulumi.Input[bool]] = None,
- should_tag_enis: Optional[pulumi.Input[bool]] = None,
- should_tag_snapshots: Optional[pulumi.Input[bool]] = None,
- should_tag_volumes: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if should_tag_amis is None and 'shouldTagAmis' in kwargs:
- should_tag_amis = kwargs['shouldTagAmis']
- if should_tag_enis is None and 'shouldTagEnis' in kwargs:
- should_tag_enis = kwargs['shouldTagEnis']
- if should_tag_snapshots is None and 'shouldTagSnapshots' in kwargs:
- should_tag_snapshots = kwargs['shouldTagSnapshots']
- if should_tag_volumes is None and 'shouldTagVolumes' in kwargs:
- should_tag_volumes = kwargs['shouldTagVolumes']
-
if should_tag_amis is not None:
- _setter("should_tag_amis", should_tag_amis)
+ pulumi.set(__self__, "should_tag_amis", should_tag_amis)
if should_tag_enis is not None:
- _setter("should_tag_enis", should_tag_enis)
+ pulumi.set(__self__, "should_tag_enis", should_tag_enis)
if should_tag_snapshots is not None:
- _setter("should_tag_snapshots", should_tag_snapshots)
+ pulumi.set(__self__, "should_tag_snapshots", should_tag_snapshots)
if should_tag_volumes is not None:
- _setter("should_tag_volumes", should_tag_volumes)
+ pulumi.set(__self__, "should_tag_volumes", should_tag_volumes)
@property
@pulumi.getter(name="shouldTagAmis")
@@ -5202,28 +3813,9 @@ def __init__(__self__, *,
:param pulumi.Input[str] perform_at: In the event of a fallback to On-Demand instances, select the time period to revert back to Spot. Supported Arguments – always (default), timeWindow, never. For timeWindow or never to be valid the group must have availabilityOriented OR persistence defined.
:param pulumi.Input[Sequence[pulumi.Input[str]]] time_windows: Specify a list of time windows for to execute revertToSpot strategy. Time window format: `ddd:hh:mm-ddd:hh:mm`. Example: `Mon:03:00-Wed:02:30`
"""
- ElastigroupRevertToSpotArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- perform_at=perform_at,
- time_windows=time_windows,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- perform_at: Optional[pulumi.Input[str]] = None,
- time_windows: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if perform_at is None and 'performAt' in kwargs:
- perform_at = kwargs['performAt']
- if perform_at is None:
- raise TypeError("Missing 'perform_at' argument")
- if time_windows is None and 'timeWindows' in kwargs:
- time_windows = kwargs['timeWindows']
-
- _setter("perform_at", perform_at)
+ pulumi.set(__self__, "perform_at", perform_at)
if time_windows is not None:
- _setter("time_windows", time_windows)
+ pulumi.set(__self__, "time_windows", time_windows)
@property
@pulumi.getter(name="performAt")
@@ -5303,118 +3895,45 @@ def __init__(__self__, *,
When using `updateCapacity` – set the fields `minimum`, `maximum`, and `target`
:param pulumi.Input[str] unit: The unit for the alarm's associated metric. Valid values: `"percent`, `"seconds"`, `"microseconds"`, `"milliseconds"`, `"bytes"`, `"kilobytes"`, `"megabytes"`, `"gigabytes"`, `"terabytes"`, `"bits"`, `"kilobits"`, `"megabits"`, `"gigabits"`, `"terabits"`, `"count"`, `"bytes/second"`, `"kilobytes/second"`, `"megabytes/second"`, `"gigabytes/second"`, `"terabytes/second"`, `"bits/second"`, `"kilobits/second"`, `"megabits/second"`, `"gigabits/second"`, `"terabits/second"`, `"count/second"`, `"none"`.
"""
- ElastigroupScalingDownPolicyArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- metric_name=metric_name,
- namespace=namespace,
- policy_name=policy_name,
- action_type=action_type,
- adjustment=adjustment,
- cooldown=cooldown,
- dimensions=dimensions,
- evaluation_periods=evaluation_periods,
- is_enabled=is_enabled,
- max_target_capacity=max_target_capacity,
- maximum=maximum,
- min_target_capacity=min_target_capacity,
- minimum=minimum,
- operator=operator,
- period=period,
- source=source,
- statistic=statistic,
- step_adjustments=step_adjustments,
- target=target,
- threshold=threshold,
- unit=unit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- metric_name: Optional[pulumi.Input[str]] = None,
- namespace: Optional[pulumi.Input[str]] = None,
- policy_name: Optional[pulumi.Input[str]] = None,
- action_type: Optional[pulumi.Input[str]] = None,
- adjustment: Optional[pulumi.Input[str]] = None,
- cooldown: Optional[pulumi.Input[int]] = None,
- dimensions: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyDimensionArgs']]]] = None,
- evaluation_periods: Optional[pulumi.Input[int]] = None,
- is_enabled: Optional[pulumi.Input[bool]] = None,
- max_target_capacity: Optional[pulumi.Input[str]] = None,
- maximum: Optional[pulumi.Input[str]] = None,
- min_target_capacity: Optional[pulumi.Input[str]] = None,
- minimum: Optional[pulumi.Input[str]] = None,
- operator: Optional[pulumi.Input[str]] = None,
- period: Optional[pulumi.Input[int]] = None,
- source: Optional[pulumi.Input[str]] = None,
- statistic: Optional[pulumi.Input[str]] = None,
- step_adjustments: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyStepAdjustmentArgs']]]] = None,
- target: Optional[pulumi.Input[str]] = None,
- threshold: Optional[pulumi.Input[float]] = None,
- unit: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if metric_name is None and 'metricName' in kwargs:
- metric_name = kwargs['metricName']
- if metric_name is None:
- raise TypeError("Missing 'metric_name' argument")
- if namespace is None:
- raise TypeError("Missing 'namespace' argument")
- if policy_name is None and 'policyName' in kwargs:
- policy_name = kwargs['policyName']
- if policy_name is None:
- raise TypeError("Missing 'policy_name' argument")
- if action_type is None and 'actionType' in kwargs:
- action_type = kwargs['actionType']
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
- if max_target_capacity is None and 'maxTargetCapacity' in kwargs:
- max_target_capacity = kwargs['maxTargetCapacity']
- if min_target_capacity is None and 'minTargetCapacity' in kwargs:
- min_target_capacity = kwargs['minTargetCapacity']
- if step_adjustments is None and 'stepAdjustments' in kwargs:
- step_adjustments = kwargs['stepAdjustments']
-
- _setter("metric_name", metric_name)
- _setter("namespace", namespace)
- _setter("policy_name", policy_name)
+ pulumi.set(__self__, "metric_name", metric_name)
+ pulumi.set(__self__, "namespace", namespace)
+ pulumi.set(__self__, "policy_name", policy_name)
if action_type is not None:
- _setter("action_type", action_type)
+ pulumi.set(__self__, "action_type", action_type)
if adjustment is not None:
- _setter("adjustment", adjustment)
+ pulumi.set(__self__, "adjustment", adjustment)
if cooldown is not None:
- _setter("cooldown", cooldown)
+ pulumi.set(__self__, "cooldown", cooldown)
if dimensions is not None:
- _setter("dimensions", dimensions)
+ pulumi.set(__self__, "dimensions", dimensions)
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
if is_enabled is not None:
- _setter("is_enabled", is_enabled)
+ pulumi.set(__self__, "is_enabled", is_enabled)
if max_target_capacity is not None:
- _setter("max_target_capacity", max_target_capacity)
+ pulumi.set(__self__, "max_target_capacity", max_target_capacity)
if maximum is not None:
- _setter("maximum", maximum)
+ pulumi.set(__self__, "maximum", maximum)
if min_target_capacity is not None:
- _setter("min_target_capacity", min_target_capacity)
+ pulumi.set(__self__, "min_target_capacity", min_target_capacity)
if minimum is not None:
- _setter("minimum", minimum)
+ pulumi.set(__self__, "minimum", minimum)
if operator is not None:
- _setter("operator", operator)
+ pulumi.set(__self__, "operator", operator)
if period is not None:
- _setter("period", period)
+ pulumi.set(__self__, "period", period)
if source is not None:
- _setter("source", source)
+ pulumi.set(__self__, "source", source)
if statistic is not None:
- _setter("statistic", statistic)
+ pulumi.set(__self__, "statistic", statistic)
if step_adjustments is not None:
- _setter("step_adjustments", step_adjustments)
+ pulumi.set(__self__, "step_adjustments", step_adjustments)
if target is not None:
- _setter("target", target)
+ pulumi.set(__self__, "target", target)
if threshold is not None:
- _setter("threshold", threshold)
+ pulumi.set(__self__, "threshold", threshold)
if unit is not None:
- _setter("unit", unit)
+ pulumi.set(__self__, "unit", unit)
@property
@pulumi.getter(name="metricName")
@@ -5682,24 +4201,9 @@ def __init__(__self__, *,
:param pulumi.Input[str] name: The group name.
:param pulumi.Input[str] value: The dimension value.
"""
- ElastigroupScalingDownPolicyDimensionArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
-
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if value is not None:
- _setter("value", value)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -5742,25 +4246,8 @@ def __init__(__self__, *,
When using `adjustment` – set the field `adjustment`
When using `updateCapacity` – set the fields `minimum`, `maximum`, and `target`
"""
- ElastigroupScalingDownPolicyStepAdjustmentArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- action=action,
- threshold=threshold,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- action: Optional[pulumi.Input['ElastigroupScalingDownPolicyStepAdjustmentActionArgs']] = None,
- threshold: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if action is None:
- raise TypeError("Missing 'action' argument")
- if threshold is None:
- raise TypeError("Missing 'threshold' argument")
-
- _setter("action", action)
- _setter("threshold", threshold)
+ pulumi.set(__self__, "action", action)
+ pulumi.set(__self__, "threshold", threshold)
@property
@pulumi.getter
@@ -5813,48 +4300,19 @@ def __init__(__self__, *,
:param pulumi.Input[str] minimum: The minimal number of instances to have in the group.
:param pulumi.Input[str] target: The target number of instances to have in the group.
"""
- ElastigroupScalingDownPolicyStepAdjustmentActionArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- type=type,
- adjustment=adjustment,
- max_target_capacity=max_target_capacity,
- maximum=maximum,
- min_target_capacity=min_target_capacity,
- minimum=minimum,
- target=target,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- type: Optional[pulumi.Input[str]] = None,
- adjustment: Optional[pulumi.Input[str]] = None,
- max_target_capacity: Optional[pulumi.Input[str]] = None,
- maximum: Optional[pulumi.Input[str]] = None,
- min_target_capacity: Optional[pulumi.Input[str]] = None,
- minimum: Optional[pulumi.Input[str]] = None,
- target: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if type is None:
- raise TypeError("Missing 'type' argument")
- if max_target_capacity is None and 'maxTargetCapacity' in kwargs:
- max_target_capacity = kwargs['maxTargetCapacity']
- if min_target_capacity is None and 'minTargetCapacity' in kwargs:
- min_target_capacity = kwargs['minTargetCapacity']
-
- _setter("type", type)
+ pulumi.set(__self__, "type", type)
if adjustment is not None:
- _setter("adjustment", adjustment)
+ pulumi.set(__self__, "adjustment", adjustment)
if max_target_capacity is not None:
- _setter("max_target_capacity", max_target_capacity)
+ pulumi.set(__self__, "max_target_capacity", max_target_capacity)
if maximum is not None:
- _setter("maximum", maximum)
+ pulumi.set(__self__, "maximum", maximum)
if min_target_capacity is not None:
- _setter("min_target_capacity", min_target_capacity)
+ pulumi.set(__self__, "min_target_capacity", min_target_capacity)
if minimum is not None:
- _setter("minimum", minimum)
+ pulumi.set(__self__, "minimum", minimum)
if target is not None:
- _setter("target", target)
+ pulumi.set(__self__, "target", target)
@property
@pulumi.getter
@@ -5950,27 +4408,10 @@ def __init__(__self__, *,
:param pulumi.Input[bool] terminate_at_end_of_billing_hour: Specify whether to terminate instances at the end of each billing hour.
:param pulumi.Input[str] termination_policy: Determines whether to terminate the newest instances when performing a scaling action. Valid values: `"default"`, `"newestInstance"`.
"""
- ElastigroupScalingStrategyArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- terminate_at_end_of_billing_hour=terminate_at_end_of_billing_hour,
- termination_policy=termination_policy,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- terminate_at_end_of_billing_hour: Optional[pulumi.Input[bool]] = None,
- termination_policy: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if terminate_at_end_of_billing_hour is None and 'terminateAtEndOfBillingHour' in kwargs:
- terminate_at_end_of_billing_hour = kwargs['terminateAtEndOfBillingHour']
- if termination_policy is None and 'terminationPolicy' in kwargs:
- termination_policy = kwargs['terminationPolicy']
-
if terminate_at_end_of_billing_hour is not None:
- _setter("terminate_at_end_of_billing_hour", terminate_at_end_of_billing_hour)
+ pulumi.set(__self__, "terminate_at_end_of_billing_hour", terminate_at_end_of_billing_hour)
if termination_policy is not None:
- _setter("termination_policy", termination_policy)
+ pulumi.set(__self__, "termination_policy", termination_policy)
@property
@pulumi.getter(name="terminateAtEndOfBillingHour")
@@ -6040,81 +4481,28 @@ def __init__(__self__, *,
:param pulumi.Input[str] statistic: String, the metric statistics to return. For information about specific statistics go to [Statistics](http://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/index.html?CHAP_TerminologyandKeyConcepts.html#Statistic) in the Amazon CloudWatch Developer Guide.
:param pulumi.Input[str] unit: String, tThe unit for the alarm's associated metric. Valid values: `"percent`, `"seconds"`, `"microseconds"`, `"milliseconds"`, `"bytes"`, `"kilobytes"`, `"megabytes"`, `"gigabytes"`, `"terabytes"`, `"bits"`, `"kilobits"`, `"megabits"`, `"gigabits"`, `"terabits"`, `"count"`, `"bytes/second"`, `"kilobytes/second"`, `"megabytes/second"`, `"gigabytes/second"`, `"terabytes/second"`, `"bits/second"`, `"kilobits/second"`, `"megabits/second"`, `"gigabits/second"`, `"terabits/second"`, `"count/second"`, `"none"`.
"""
- ElastigroupScalingTargetPolicyArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- metric_name=metric_name,
- namespace=namespace,
- policy_name=policy_name,
- target=target,
- cooldown=cooldown,
- dimensions=dimensions,
- evaluation_periods=evaluation_periods,
- max_capacity_per_scale=max_capacity_per_scale,
- period=period,
- predictive_mode=predictive_mode,
- source=source,
- statistic=statistic,
- unit=unit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- metric_name: Optional[pulumi.Input[str]] = None,
- namespace: Optional[pulumi.Input[str]] = None,
- policy_name: Optional[pulumi.Input[str]] = None,
- target: Optional[pulumi.Input[float]] = None,
- cooldown: Optional[pulumi.Input[int]] = None,
- dimensions: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingTargetPolicyDimensionArgs']]]] = None,
- evaluation_periods: Optional[pulumi.Input[int]] = None,
- max_capacity_per_scale: Optional[pulumi.Input[str]] = None,
- period: Optional[pulumi.Input[int]] = None,
- predictive_mode: Optional[pulumi.Input[str]] = None,
- source: Optional[pulumi.Input[str]] = None,
- statistic: Optional[pulumi.Input[str]] = None,
- unit: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if metric_name is None and 'metricName' in kwargs:
- metric_name = kwargs['metricName']
- if metric_name is None:
- raise TypeError("Missing 'metric_name' argument")
- if namespace is None:
- raise TypeError("Missing 'namespace' argument")
- if policy_name is None and 'policyName' in kwargs:
- policy_name = kwargs['policyName']
- if policy_name is None:
- raise TypeError("Missing 'policy_name' argument")
- if target is None:
- raise TypeError("Missing 'target' argument")
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
- if max_capacity_per_scale is None and 'maxCapacityPerScale' in kwargs:
- max_capacity_per_scale = kwargs['maxCapacityPerScale']
- if predictive_mode is None and 'predictiveMode' in kwargs:
- predictive_mode = kwargs['predictiveMode']
-
- _setter("metric_name", metric_name)
- _setter("namespace", namespace)
- _setter("policy_name", policy_name)
- _setter("target", target)
+ pulumi.set(__self__, "metric_name", metric_name)
+ pulumi.set(__self__, "namespace", namespace)
+ pulumi.set(__self__, "policy_name", policy_name)
+ pulumi.set(__self__, "target", target)
if cooldown is not None:
- _setter("cooldown", cooldown)
+ pulumi.set(__self__, "cooldown", cooldown)
if dimensions is not None:
- _setter("dimensions", dimensions)
+ pulumi.set(__self__, "dimensions", dimensions)
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
if max_capacity_per_scale is not None:
- _setter("max_capacity_per_scale", max_capacity_per_scale)
+ pulumi.set(__self__, "max_capacity_per_scale", max_capacity_per_scale)
if period is not None:
- _setter("period", period)
+ pulumi.set(__self__, "period", period)
if predictive_mode is not None:
- _setter("predictive_mode", predictive_mode)
+ pulumi.set(__self__, "predictive_mode", predictive_mode)
if source is not None:
- _setter("source", source)
+ pulumi.set(__self__, "source", source)
if statistic is not None:
- _setter("statistic", statistic)
+ pulumi.set(__self__, "statistic", statistic)
if unit is not None:
- _setter("unit", unit)
+ pulumi.set(__self__, "unit", unit)
@property
@pulumi.getter(name="metricName")
@@ -6294,24 +4682,9 @@ def __init__(__self__, *,
:param pulumi.Input[str] name: The group name.
:param pulumi.Input[str] value: The dimension value.
"""
- ElastigroupScalingTargetPolicyDimensionArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
-
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if value is not None:
- _setter("value", value)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -6392,118 +4765,45 @@ def __init__(__self__, *,
When using `updateCapacity` – set the fields `minimum`, `maximum`, and `target`
:param pulumi.Input[str] unit: The unit for the alarm's associated metric. Valid values: `"percent`, `"seconds"`, `"microseconds"`, `"milliseconds"`, `"bytes"`, `"kilobytes"`, `"megabytes"`, `"gigabytes"`, `"terabytes"`, `"bits"`, `"kilobits"`, `"megabits"`, `"gigabits"`, `"terabits"`, `"count"`, `"bytes/second"`, `"kilobytes/second"`, `"megabytes/second"`, `"gigabytes/second"`, `"terabytes/second"`, `"bits/second"`, `"kilobits/second"`, `"megabits/second"`, `"gigabits/second"`, `"terabits/second"`, `"count/second"`, `"none"`.
"""
- ElastigroupScalingUpPolicyArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- metric_name=metric_name,
- namespace=namespace,
- policy_name=policy_name,
- action_type=action_type,
- adjustment=adjustment,
- cooldown=cooldown,
- dimensions=dimensions,
- evaluation_periods=evaluation_periods,
- is_enabled=is_enabled,
- max_target_capacity=max_target_capacity,
- maximum=maximum,
- min_target_capacity=min_target_capacity,
- minimum=minimum,
- operator=operator,
- period=period,
- source=source,
- statistic=statistic,
- step_adjustments=step_adjustments,
- target=target,
- threshold=threshold,
- unit=unit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- metric_name: Optional[pulumi.Input[str]] = None,
- namespace: Optional[pulumi.Input[str]] = None,
- policy_name: Optional[pulumi.Input[str]] = None,
- action_type: Optional[pulumi.Input[str]] = None,
- adjustment: Optional[pulumi.Input[str]] = None,
- cooldown: Optional[pulumi.Input[int]] = None,
- dimensions: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyDimensionArgs']]]] = None,
- evaluation_periods: Optional[pulumi.Input[int]] = None,
- is_enabled: Optional[pulumi.Input[bool]] = None,
- max_target_capacity: Optional[pulumi.Input[str]] = None,
- maximum: Optional[pulumi.Input[str]] = None,
- min_target_capacity: Optional[pulumi.Input[str]] = None,
- minimum: Optional[pulumi.Input[str]] = None,
- operator: Optional[pulumi.Input[str]] = None,
- period: Optional[pulumi.Input[int]] = None,
- source: Optional[pulumi.Input[str]] = None,
- statistic: Optional[pulumi.Input[str]] = None,
- step_adjustments: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyStepAdjustmentArgs']]]] = None,
- target: Optional[pulumi.Input[str]] = None,
- threshold: Optional[pulumi.Input[float]] = None,
- unit: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if metric_name is None and 'metricName' in kwargs:
- metric_name = kwargs['metricName']
- if metric_name is None:
- raise TypeError("Missing 'metric_name' argument")
- if namespace is None:
- raise TypeError("Missing 'namespace' argument")
- if policy_name is None and 'policyName' in kwargs:
- policy_name = kwargs['policyName']
- if policy_name is None:
- raise TypeError("Missing 'policy_name' argument")
- if action_type is None and 'actionType' in kwargs:
- action_type = kwargs['actionType']
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
- if max_target_capacity is None and 'maxTargetCapacity' in kwargs:
- max_target_capacity = kwargs['maxTargetCapacity']
- if min_target_capacity is None and 'minTargetCapacity' in kwargs:
- min_target_capacity = kwargs['minTargetCapacity']
- if step_adjustments is None and 'stepAdjustments' in kwargs:
- step_adjustments = kwargs['stepAdjustments']
-
- _setter("metric_name", metric_name)
- _setter("namespace", namespace)
- _setter("policy_name", policy_name)
+ pulumi.set(__self__, "metric_name", metric_name)
+ pulumi.set(__self__, "namespace", namespace)
+ pulumi.set(__self__, "policy_name", policy_name)
if action_type is not None:
- _setter("action_type", action_type)
+ pulumi.set(__self__, "action_type", action_type)
if adjustment is not None:
- _setter("adjustment", adjustment)
+ pulumi.set(__self__, "adjustment", adjustment)
if cooldown is not None:
- _setter("cooldown", cooldown)
+ pulumi.set(__self__, "cooldown", cooldown)
if dimensions is not None:
- _setter("dimensions", dimensions)
+ pulumi.set(__self__, "dimensions", dimensions)
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
if is_enabled is not None:
- _setter("is_enabled", is_enabled)
+ pulumi.set(__self__, "is_enabled", is_enabled)
if max_target_capacity is not None:
- _setter("max_target_capacity", max_target_capacity)
+ pulumi.set(__self__, "max_target_capacity", max_target_capacity)
if maximum is not None:
- _setter("maximum", maximum)
+ pulumi.set(__self__, "maximum", maximum)
if min_target_capacity is not None:
- _setter("min_target_capacity", min_target_capacity)
+ pulumi.set(__self__, "min_target_capacity", min_target_capacity)
if minimum is not None:
- _setter("minimum", minimum)
+ pulumi.set(__self__, "minimum", minimum)
if operator is not None:
- _setter("operator", operator)
+ pulumi.set(__self__, "operator", operator)
if period is not None:
- _setter("period", period)
+ pulumi.set(__self__, "period", period)
if source is not None:
- _setter("source", source)
+ pulumi.set(__self__, "source", source)
if statistic is not None:
- _setter("statistic", statistic)
+ pulumi.set(__self__, "statistic", statistic)
if step_adjustments is not None:
- _setter("step_adjustments", step_adjustments)
+ pulumi.set(__self__, "step_adjustments", step_adjustments)
if target is not None:
- _setter("target", target)
+ pulumi.set(__self__, "target", target)
if threshold is not None:
- _setter("threshold", threshold)
+ pulumi.set(__self__, "threshold", threshold)
if unit is not None:
- _setter("unit", unit)
+ pulumi.set(__self__, "unit", unit)
@property
@pulumi.getter(name="metricName")
@@ -6772,24 +5072,9 @@ def __init__(__self__, *,
:param pulumi.Input[str] name: The group name.
:param pulumi.Input[str] value: The dimension value.
"""
- ElastigroupScalingUpPolicyDimensionArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
-
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if value is not None:
- _setter("value", value)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -6832,25 +5117,8 @@ def __init__(__self__, *,
When using `adjustment` – set the field `adjustment`
When using `updateCapacity` – set the fields `minimum`, `maximum`, and `target`
"""
- ElastigroupScalingUpPolicyStepAdjustmentArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- action=action,
- threshold=threshold,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- action: Optional[pulumi.Input['ElastigroupScalingUpPolicyStepAdjustmentActionArgs']] = None,
- threshold: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if action is None:
- raise TypeError("Missing 'action' argument")
- if threshold is None:
- raise TypeError("Missing 'threshold' argument")
-
- _setter("action", action)
- _setter("threshold", threshold)
+ pulumi.set(__self__, "action", action)
+ pulumi.set(__self__, "threshold", threshold)
@property
@pulumi.getter
@@ -6903,48 +5171,19 @@ def __init__(__self__, *,
:param pulumi.Input[str] minimum: The minimal number of instances to have in the group.
:param pulumi.Input[str] target: The target number of instances to have in the group.
"""
- ElastigroupScalingUpPolicyStepAdjustmentActionArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- type=type,
- adjustment=adjustment,
- max_target_capacity=max_target_capacity,
- maximum=maximum,
- min_target_capacity=min_target_capacity,
- minimum=minimum,
- target=target,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- type: Optional[pulumi.Input[str]] = None,
- adjustment: Optional[pulumi.Input[str]] = None,
- max_target_capacity: Optional[pulumi.Input[str]] = None,
- maximum: Optional[pulumi.Input[str]] = None,
- min_target_capacity: Optional[pulumi.Input[str]] = None,
- minimum: Optional[pulumi.Input[str]] = None,
- target: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if type is None:
- raise TypeError("Missing 'type' argument")
- if max_target_capacity is None and 'maxTargetCapacity' in kwargs:
- max_target_capacity = kwargs['maxTargetCapacity']
- if min_target_capacity is None and 'minTargetCapacity' in kwargs:
- min_target_capacity = kwargs['minTargetCapacity']
-
- _setter("type", type)
+ pulumi.set(__self__, "type", type)
if adjustment is not None:
- _setter("adjustment", adjustment)
+ pulumi.set(__self__, "adjustment", adjustment)
if max_target_capacity is not None:
- _setter("max_target_capacity", max_target_capacity)
+ pulumi.set(__self__, "max_target_capacity", max_target_capacity)
if maximum is not None:
- _setter("maximum", maximum)
+ pulumi.set(__self__, "maximum", maximum)
if min_target_capacity is not None:
- _setter("min_target_capacity", min_target_capacity)
+ pulumi.set(__self__, "min_target_capacity", min_target_capacity)
if minimum is not None:
- _setter("minimum", minimum)
+ pulumi.set(__self__, "minimum", minimum)
if target is not None:
- _setter("target", target)
+ pulumi.set(__self__, "target", target)
@property
@pulumi.getter
@@ -7072,102 +5311,35 @@ def __init__(__self__, *,
:param pulumi.Input[str] start_time: Set a start time for one time tasks.
:param pulumi.Input[str] target_capacity: The desired number of instances the group should have.
"""
- ElastigroupScheduledTaskArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- task_type=task_type,
- adjustment=adjustment,
- adjustment_percentage=adjustment_percentage,
- batch_size_percentage=batch_size_percentage,
- cron_expression=cron_expression,
- frequency=frequency,
- grace_period=grace_period,
- is_enabled=is_enabled,
- max_capacity=max_capacity,
- min_capacity=min_capacity,
- scale_max_capacity=scale_max_capacity,
- scale_min_capacity=scale_min_capacity,
- scale_target_capacity=scale_target_capacity,
- start_time=start_time,
- target_capacity=target_capacity,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- task_type: Optional[pulumi.Input[str]] = None,
- adjustment: Optional[pulumi.Input[str]] = None,
- adjustment_percentage: Optional[pulumi.Input[str]] = None,
- batch_size_percentage: Optional[pulumi.Input[str]] = None,
- cron_expression: Optional[pulumi.Input[str]] = None,
- frequency: Optional[pulumi.Input[str]] = None,
- grace_period: Optional[pulumi.Input[str]] = None,
- is_enabled: Optional[pulumi.Input[bool]] = None,
- max_capacity: Optional[pulumi.Input[str]] = None,
- min_capacity: Optional[pulumi.Input[str]] = None,
- scale_max_capacity: Optional[pulumi.Input[str]] = None,
- scale_min_capacity: Optional[pulumi.Input[str]] = None,
- scale_target_capacity: Optional[pulumi.Input[str]] = None,
- start_time: Optional[pulumi.Input[str]] = None,
- target_capacity: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if task_type is None and 'taskType' in kwargs:
- task_type = kwargs['taskType']
- if task_type is None:
- raise TypeError("Missing 'task_type' argument")
- if adjustment_percentage is None and 'adjustmentPercentage' in kwargs:
- adjustment_percentage = kwargs['adjustmentPercentage']
- if batch_size_percentage is None and 'batchSizePercentage' in kwargs:
- batch_size_percentage = kwargs['batchSizePercentage']
- if cron_expression is None and 'cronExpression' in kwargs:
- cron_expression = kwargs['cronExpression']
- if grace_period is None and 'gracePeriod' in kwargs:
- grace_period = kwargs['gracePeriod']
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
- if max_capacity is None and 'maxCapacity' in kwargs:
- max_capacity = kwargs['maxCapacity']
- if min_capacity is None and 'minCapacity' in kwargs:
- min_capacity = kwargs['minCapacity']
- if scale_max_capacity is None and 'scaleMaxCapacity' in kwargs:
- scale_max_capacity = kwargs['scaleMaxCapacity']
- if scale_min_capacity is None and 'scaleMinCapacity' in kwargs:
- scale_min_capacity = kwargs['scaleMinCapacity']
- if scale_target_capacity is None and 'scaleTargetCapacity' in kwargs:
- scale_target_capacity = kwargs['scaleTargetCapacity']
- if start_time is None and 'startTime' in kwargs:
- start_time = kwargs['startTime']
- if target_capacity is None and 'targetCapacity' in kwargs:
- target_capacity = kwargs['targetCapacity']
-
- _setter("task_type", task_type)
+ pulumi.set(__self__, "task_type", task_type)
if adjustment is not None:
- _setter("adjustment", adjustment)
+ pulumi.set(__self__, "adjustment", adjustment)
if adjustment_percentage is not None:
- _setter("adjustment_percentage", adjustment_percentage)
+ pulumi.set(__self__, "adjustment_percentage", adjustment_percentage)
if batch_size_percentage is not None:
- _setter("batch_size_percentage", batch_size_percentage)
+ pulumi.set(__self__, "batch_size_percentage", batch_size_percentage)
if cron_expression is not None:
- _setter("cron_expression", cron_expression)
+ pulumi.set(__self__, "cron_expression", cron_expression)
if frequency is not None:
- _setter("frequency", frequency)
+ pulumi.set(__self__, "frequency", frequency)
if grace_period is not None:
- _setter("grace_period", grace_period)
+ pulumi.set(__self__, "grace_period", grace_period)
if is_enabled is not None:
- _setter("is_enabled", is_enabled)
+ pulumi.set(__self__, "is_enabled", is_enabled)
if max_capacity is not None:
- _setter("max_capacity", max_capacity)
+ pulumi.set(__self__, "max_capacity", max_capacity)
if min_capacity is not None:
- _setter("min_capacity", min_capacity)
+ pulumi.set(__self__, "min_capacity", min_capacity)
if scale_max_capacity is not None:
- _setter("scale_max_capacity", scale_max_capacity)
+ pulumi.set(__self__, "scale_max_capacity", scale_max_capacity)
if scale_min_capacity is not None:
- _setter("scale_min_capacity", scale_min_capacity)
+ pulumi.set(__self__, "scale_min_capacity", scale_min_capacity)
if scale_target_capacity is not None:
- _setter("scale_target_capacity", scale_target_capacity)
+ pulumi.set(__self__, "scale_target_capacity", scale_target_capacity)
if start_time is not None:
- _setter("start_time", start_time)
+ pulumi.set(__self__, "start_time", start_time)
if target_capacity is not None:
- _setter("target_capacity", target_capacity)
+ pulumi.set(__self__, "target_capacity", target_capacity)
@property
@pulumi.getter(name="taskType")
@@ -7371,24 +5543,9 @@ def __init__(__self__, *,
import pulumi
```
"""
- ElastigroupSignalArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- timeout=timeout,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- timeout: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
-
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if timeout is not None:
- _setter("timeout", timeout)
+ pulumi.set(__self__, "timeout", timeout)
@property
@pulumi.getter
@@ -7440,39 +5597,14 @@ def __init__(__self__, *,
```
:param pulumi.Input[bool] should_delete_volumes: For stateful groups: remove persistent volumes.
"""
- ElastigroupStatefulDeallocationArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- should_delete_images=should_delete_images,
- should_delete_network_interfaces=should_delete_network_interfaces,
- should_delete_snapshots=should_delete_snapshots,
- should_delete_volumes=should_delete_volumes,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- should_delete_images: Optional[pulumi.Input[bool]] = None,
- should_delete_network_interfaces: Optional[pulumi.Input[bool]] = None,
- should_delete_snapshots: Optional[pulumi.Input[bool]] = None,
- should_delete_volumes: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if should_delete_images is None and 'shouldDeleteImages' in kwargs:
- should_delete_images = kwargs['shouldDeleteImages']
- if should_delete_network_interfaces is None and 'shouldDeleteNetworkInterfaces' in kwargs:
- should_delete_network_interfaces = kwargs['shouldDeleteNetworkInterfaces']
- if should_delete_snapshots is None and 'shouldDeleteSnapshots' in kwargs:
- should_delete_snapshots = kwargs['shouldDeleteSnapshots']
- if should_delete_volumes is None and 'shouldDeleteVolumes' in kwargs:
- should_delete_volumes = kwargs['shouldDeleteVolumes']
-
if should_delete_images is not None:
- _setter("should_delete_images", should_delete_images)
+ pulumi.set(__self__, "should_delete_images", should_delete_images)
if should_delete_network_interfaces is not None:
- _setter("should_delete_network_interfaces", should_delete_network_interfaces)
+ pulumi.set(__self__, "should_delete_network_interfaces", should_delete_network_interfaces)
if should_delete_snapshots is not None:
- _setter("should_delete_snapshots", should_delete_snapshots)
+ pulumi.set(__self__, "should_delete_snapshots", should_delete_snapshots)
if should_delete_volumes is not None:
- _setter("should_delete_volumes", should_delete_volumes)
+ pulumi.set(__self__, "should_delete_volumes", should_delete_volumes)
@property
@pulumi.getter(name="shouldDeleteImages")
@@ -7544,27 +5676,8 @@ def __init__(__self__, *,
import pulumi
```
"""
- ElastigroupStatefulInstanceActionArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- stateful_instance_id=stateful_instance_id,
- type=type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- stateful_instance_id: Optional[pulumi.Input[str]] = None,
- type: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if stateful_instance_id is None and 'statefulInstanceId' in kwargs:
- stateful_instance_id = kwargs['statefulInstanceId']
- if stateful_instance_id is None:
- raise TypeError("Missing 'stateful_instance_id' argument")
- if type is None:
- raise TypeError("Missing 'type' argument")
-
- _setter("stateful_instance_id", stateful_instance_id)
- _setter("type", type)
+ pulumi.set(__self__, "stateful_instance_id", stateful_instance_id)
+ pulumi.set(__self__, "type", type)
@property
@pulumi.getter(name="statefulInstanceId")
@@ -7605,23 +5718,10 @@ def __init__(__self__, *,
"""
:param pulumi.Input[str] value: The dimension value.
"""
- ElastigroupTagArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if key is not None:
- _setter("key", key)
+ pulumi.set(__self__, "key", key)
if value is not None:
- _setter("value", value)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -7658,41 +5758,12 @@ def __init__(__self__, *,
:param pulumi.Input[bool] auto_apply_tags: Enables updates to tags without rolling the group when set to `true`.
:param pulumi.Input['ElastigroupUpdatePolicyRollConfigArgs'] roll_config: While used, you can control whether the group should perform a deployment after an update to the configuration.
"""
- ElastigroupUpdatePolicyArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- should_resume_stateful=should_resume_stateful,
- should_roll=should_roll,
- auto_apply_tags=auto_apply_tags,
- roll_config=roll_config,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- should_resume_stateful: Optional[pulumi.Input[bool]] = None,
- should_roll: Optional[pulumi.Input[bool]] = None,
- auto_apply_tags: Optional[pulumi.Input[bool]] = None,
- roll_config: Optional[pulumi.Input['ElastigroupUpdatePolicyRollConfigArgs']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if should_resume_stateful is None and 'shouldResumeStateful' in kwargs:
- should_resume_stateful = kwargs['shouldResumeStateful']
- if should_resume_stateful is None:
- raise TypeError("Missing 'should_resume_stateful' argument")
- if should_roll is None and 'shouldRoll' in kwargs:
- should_roll = kwargs['shouldRoll']
- if should_roll is None:
- raise TypeError("Missing 'should_roll' argument")
- if auto_apply_tags is None and 'autoApplyTags' in kwargs:
- auto_apply_tags = kwargs['autoApplyTags']
- if roll_config is None and 'rollConfig' in kwargs:
- roll_config = kwargs['rollConfig']
-
- _setter("should_resume_stateful", should_resume_stateful)
- _setter("should_roll", should_roll)
+ pulumi.set(__self__, "should_resume_stateful", should_resume_stateful)
+ pulumi.set(__self__, "should_roll", should_roll)
if auto_apply_tags is not None:
- _setter("auto_apply_tags", auto_apply_tags)
+ pulumi.set(__self__, "auto_apply_tags", auto_apply_tags)
if roll_config is not None:
- _setter("roll_config", roll_config)
+ pulumi.set(__self__, "roll_config", roll_config)
@property
@pulumi.getter(name="shouldResumeStateful")
@@ -7760,50 +5831,17 @@ def __init__(__self__, *,
:param pulumi.Input[float] wait_for_roll_percentage: For use with `should_roll`. Sets minimum % of roll required to complete before continuing the plan. Required if `wait_for_roll_timeout` is set.
:param pulumi.Input[int] wait_for_roll_timeout: For use with `should_roll`. Sets how long to wait for the deployed % of a roll to exceed `wait_for_roll_percentage` before continuing the plan. Required if `wait_for_roll_percentage` is set.
"""
- ElastigroupUpdatePolicyRollConfigArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- batch_size_percentage=batch_size_percentage,
- grace_period=grace_period,
- health_check_type=health_check_type,
- strategy=strategy,
- wait_for_roll_percentage=wait_for_roll_percentage,
- wait_for_roll_timeout=wait_for_roll_timeout,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- batch_size_percentage: Optional[pulumi.Input[int]] = None,
- grace_period: Optional[pulumi.Input[int]] = None,
- health_check_type: Optional[pulumi.Input[str]] = None,
- strategy: Optional[pulumi.Input['ElastigroupUpdatePolicyRollConfigStrategyArgs']] = None,
- wait_for_roll_percentage: Optional[pulumi.Input[float]] = None,
- wait_for_roll_timeout: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if batch_size_percentage is None and 'batchSizePercentage' in kwargs:
- batch_size_percentage = kwargs['batchSizePercentage']
- if batch_size_percentage is None:
- raise TypeError("Missing 'batch_size_percentage' argument")
- if grace_period is None and 'gracePeriod' in kwargs:
- grace_period = kwargs['gracePeriod']
- if health_check_type is None and 'healthCheckType' in kwargs:
- health_check_type = kwargs['healthCheckType']
- if wait_for_roll_percentage is None and 'waitForRollPercentage' in kwargs:
- wait_for_roll_percentage = kwargs['waitForRollPercentage']
- if wait_for_roll_timeout is None and 'waitForRollTimeout' in kwargs:
- wait_for_roll_timeout = kwargs['waitForRollTimeout']
-
- _setter("batch_size_percentage", batch_size_percentage)
+ pulumi.set(__self__, "batch_size_percentage", batch_size_percentage)
if grace_period is not None:
- _setter("grace_period", grace_period)
+ pulumi.set(__self__, "grace_period", grace_period)
if health_check_type is not None:
- _setter("health_check_type", health_check_type)
+ pulumi.set(__self__, "health_check_type", health_check_type)
if strategy is not None:
- _setter("strategy", strategy)
+ pulumi.set(__self__, "strategy", strategy)
if wait_for_roll_percentage is not None:
- _setter("wait_for_roll_percentage", wait_for_roll_percentage)
+ pulumi.set(__self__, "wait_for_roll_percentage", wait_for_roll_percentage)
if wait_for_roll_timeout is not None:
- _setter("wait_for_roll_timeout", wait_for_roll_timeout)
+ pulumi.set(__self__, "wait_for_roll_timeout", wait_for_roll_timeout)
@property
@pulumi.getter(name="batchSizePercentage")
@@ -7891,38 +5929,13 @@ def __init__(__self__, *,
:param pulumi.Input['ElastigroupUpdatePolicyRollConfigStrategyOnFailureArgs'] on_failure: Set detach options to the deployment.
:param pulumi.Input[bool] should_drain_instances: Bool value if to wait to drain instance
"""
- ElastigroupUpdatePolicyRollConfigStrategyArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- action=action,
- batch_min_healthy_percentage=batch_min_healthy_percentage,
- on_failure=on_failure,
- should_drain_instances=should_drain_instances,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- action: Optional[pulumi.Input[str]] = None,
- batch_min_healthy_percentage: Optional[pulumi.Input[int]] = None,
- on_failure: Optional[pulumi.Input['ElastigroupUpdatePolicyRollConfigStrategyOnFailureArgs']] = None,
- should_drain_instances: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if action is None:
- raise TypeError("Missing 'action' argument")
- if batch_min_healthy_percentage is None and 'batchMinHealthyPercentage' in kwargs:
- batch_min_healthy_percentage = kwargs['batchMinHealthyPercentage']
- if on_failure is None and 'onFailure' in kwargs:
- on_failure = kwargs['onFailure']
- if should_drain_instances is None and 'shouldDrainInstances' in kwargs:
- should_drain_instances = kwargs['shouldDrainInstances']
-
- _setter("action", action)
+ pulumi.set(__self__, "action", action)
if batch_min_healthy_percentage is not None:
- _setter("batch_min_healthy_percentage", batch_min_healthy_percentage)
+ pulumi.set(__self__, "batch_min_healthy_percentage", batch_min_healthy_percentage)
if on_failure is not None:
- _setter("on_failure", on_failure)
+ pulumi.set(__self__, "on_failure", on_failure)
if should_drain_instances is not None:
- _setter("should_drain_instances", should_drain_instances)
+ pulumi.set(__self__, "should_drain_instances", should_drain_instances)
@property
@pulumi.getter
@@ -7991,46 +6004,15 @@ def __init__(__self__, *,
```
:param pulumi.Input[bool] should_handle_all_batches: Indicator if the action should apply to all batches of the deployment or only the latest batch.
"""
- ElastigroupUpdatePolicyRollConfigStrategyOnFailureArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- action_type=action_type,
- batch_num=batch_num,
- draining_timeout=draining_timeout,
- should_decrement_target_capacity=should_decrement_target_capacity,
- should_handle_all_batches=should_handle_all_batches,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- action_type: Optional[pulumi.Input[str]] = None,
- batch_num: Optional[pulumi.Input[int]] = None,
- draining_timeout: Optional[pulumi.Input[int]] = None,
- should_decrement_target_capacity: Optional[pulumi.Input[bool]] = None,
- should_handle_all_batches: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if action_type is None and 'actionType' in kwargs:
- action_type = kwargs['actionType']
- if action_type is None:
- raise TypeError("Missing 'action_type' argument")
- if batch_num is None and 'batchNum' in kwargs:
- batch_num = kwargs['batchNum']
- if draining_timeout is None and 'drainingTimeout' in kwargs:
- draining_timeout = kwargs['drainingTimeout']
- if should_decrement_target_capacity is None and 'shouldDecrementTargetCapacity' in kwargs:
- should_decrement_target_capacity = kwargs['shouldDecrementTargetCapacity']
- if should_handle_all_batches is None and 'shouldHandleAllBatches' in kwargs:
- should_handle_all_batches = kwargs['shouldHandleAllBatches']
-
- _setter("action_type", action_type)
+ pulumi.set(__self__, "action_type", action_type)
if batch_num is not None:
- _setter("batch_num", batch_num)
+ pulumi.set(__self__, "batch_num", batch_num)
if draining_timeout is not None:
- _setter("draining_timeout", draining_timeout)
+ pulumi.set(__self__, "draining_timeout", draining_timeout)
if should_decrement_target_capacity is not None:
- _setter("should_decrement_target_capacity", should_decrement_target_capacity)
+ pulumi.set(__self__, "should_decrement_target_capacity", should_decrement_target_capacity)
if should_handle_all_batches is not None:
- _setter("should_handle_all_batches", should_handle_all_batches)
+ pulumi.set(__self__, "should_handle_all_batches", should_handle_all_batches)
@property
@pulumi.getter(name="actionType")
@@ -8099,26 +6081,9 @@ class ManagedInstanceBlockDeviceMappingArgs:
def __init__(__self__, *,
device_name: pulumi.Input[str],
ebs: Optional[pulumi.Input['ManagedInstanceBlockDeviceMappingEbsArgs']] = None):
- ManagedInstanceBlockDeviceMappingArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- device_name=device_name,
- ebs=ebs,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- device_name: Optional[pulumi.Input[str]] = None,
- ebs: Optional[pulumi.Input['ManagedInstanceBlockDeviceMappingEbsArgs']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if device_name is None and 'deviceName' in kwargs:
- device_name = kwargs['deviceName']
- if device_name is None:
- raise TypeError("Missing 'device_name' argument")
-
- _setter("device_name", device_name)
+ pulumi.set(__self__, "device_name", device_name)
if ebs is not None:
- _setter("ebs", ebs)
+ pulumi.set(__self__, "ebs", ebs)
@property
@pulumi.getter(name="deviceName")
@@ -8147,41 +6112,16 @@ def __init__(__self__, *,
throughput: Optional[pulumi.Input[int]] = None,
volume_size: Optional[pulumi.Input[int]] = None,
volume_type: Optional[pulumi.Input[str]] = None):
- ManagedInstanceBlockDeviceMappingEbsArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- delete_on_termination=delete_on_termination,
- iops=iops,
- throughput=throughput,
- volume_size=volume_size,
- volume_type=volume_type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- delete_on_termination: Optional[pulumi.Input[bool]] = None,
- iops: Optional[pulumi.Input[int]] = None,
- throughput: Optional[pulumi.Input[int]] = None,
- volume_size: Optional[pulumi.Input[int]] = None,
- volume_type: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if delete_on_termination is None and 'deleteOnTermination' in kwargs:
- delete_on_termination = kwargs['deleteOnTermination']
- if volume_size is None and 'volumeSize' in kwargs:
- volume_size = kwargs['volumeSize']
- if volume_type is None and 'volumeType' in kwargs:
- volume_type = kwargs['volumeType']
-
if delete_on_termination is not None:
- _setter("delete_on_termination", delete_on_termination)
+ pulumi.set(__self__, "delete_on_termination", delete_on_termination)
if iops is not None:
- _setter("iops", iops)
+ pulumi.set(__self__, "iops", iops)
if throughput is not None:
- _setter("throughput", throughput)
+ pulumi.set(__self__, "throughput", throughput)
if volume_size is not None:
- _setter("volume_size", volume_size)
+ pulumi.set(__self__, "volume_size", volume_size)
if volume_type is not None:
- _setter("volume_type", volume_type)
+ pulumi.set(__self__, "volume_type", volume_type)
@property
@pulumi.getter(name="deleteOnTermination")
@@ -8238,51 +6178,18 @@ def __init__(__self__, *,
should_delete_snapshots: Optional[pulumi.Input[bool]] = None,
should_delete_volumes: Optional[pulumi.Input[bool]] = None,
should_terminate_instance: Optional[pulumi.Input[bool]] = None):
- ManagedInstanceDeleteArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- ami_backup_should_delete_images=ami_backup_should_delete_images,
- deallocation_config_should_delete_images=deallocation_config_should_delete_images,
- should_delete_network_interfaces=should_delete_network_interfaces,
- should_delete_snapshots=should_delete_snapshots,
- should_delete_volumes=should_delete_volumes,
- should_terminate_instance=should_terminate_instance,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- ami_backup_should_delete_images: Optional[pulumi.Input[bool]] = None,
- deallocation_config_should_delete_images: Optional[pulumi.Input[bool]] = None,
- should_delete_network_interfaces: Optional[pulumi.Input[bool]] = None,
- should_delete_snapshots: Optional[pulumi.Input[bool]] = None,
- should_delete_volumes: Optional[pulumi.Input[bool]] = None,
- should_terminate_instance: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if ami_backup_should_delete_images is None and 'amiBackupShouldDeleteImages' in kwargs:
- ami_backup_should_delete_images = kwargs['amiBackupShouldDeleteImages']
- if deallocation_config_should_delete_images is None and 'deallocationConfigShouldDeleteImages' in kwargs:
- deallocation_config_should_delete_images = kwargs['deallocationConfigShouldDeleteImages']
- if should_delete_network_interfaces is None and 'shouldDeleteNetworkInterfaces' in kwargs:
- should_delete_network_interfaces = kwargs['shouldDeleteNetworkInterfaces']
- if should_delete_snapshots is None and 'shouldDeleteSnapshots' in kwargs:
- should_delete_snapshots = kwargs['shouldDeleteSnapshots']
- if should_delete_volumes is None and 'shouldDeleteVolumes' in kwargs:
- should_delete_volumes = kwargs['shouldDeleteVolumes']
- if should_terminate_instance is None and 'shouldTerminateInstance' in kwargs:
- should_terminate_instance = kwargs['shouldTerminateInstance']
-
if ami_backup_should_delete_images is not None:
- _setter("ami_backup_should_delete_images", ami_backup_should_delete_images)
+ pulumi.set(__self__, "ami_backup_should_delete_images", ami_backup_should_delete_images)
if deallocation_config_should_delete_images is not None:
- _setter("deallocation_config_should_delete_images", deallocation_config_should_delete_images)
+ pulumi.set(__self__, "deallocation_config_should_delete_images", deallocation_config_should_delete_images)
if should_delete_network_interfaces is not None:
- _setter("should_delete_network_interfaces", should_delete_network_interfaces)
+ pulumi.set(__self__, "should_delete_network_interfaces", should_delete_network_interfaces)
if should_delete_snapshots is not None:
- _setter("should_delete_snapshots", should_delete_snapshots)
+ pulumi.set(__self__, "should_delete_snapshots", should_delete_snapshots)
if should_delete_volumes is not None:
- _setter("should_delete_volumes", should_delete_volumes)
+ pulumi.set(__self__, "should_delete_volumes", should_delete_volumes)
if should_terminate_instance is not None:
- _setter("should_terminate_instance", should_terminate_instance)
+ pulumi.set(__self__, "should_terminate_instance", should_terminate_instance)
@property
@pulumi.getter(name="amiBackupShouldDeleteImages")
@@ -8343,20 +6250,7 @@ def should_terminate_instance(self, value: Optional[pulumi.Input[bool]]):
class ManagedInstanceIntegrationRoute53Args:
def __init__(__self__, *,
domains: pulumi.Input[Sequence[pulumi.Input['ManagedInstanceIntegrationRoute53DomainArgs']]]):
- ManagedInstanceIntegrationRoute53Args._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- domains=domains,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- domains: Optional[pulumi.Input[Sequence[pulumi.Input['ManagedInstanceIntegrationRoute53DomainArgs']]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if domains is None:
- raise TypeError("Missing 'domains' argument")
-
- _setter("domains", domains)
+ pulumi.set(__self__, "domains", domains)
@property
@pulumi.getter
@@ -8375,41 +6269,12 @@ def __init__(__self__, *,
record_sets: pulumi.Input[Sequence[pulumi.Input['ManagedInstanceIntegrationRoute53DomainRecordSetArgs']]],
record_set_type: Optional[pulumi.Input[str]] = None,
spotinst_acct_id: Optional[pulumi.Input[str]] = None):
- ManagedInstanceIntegrationRoute53DomainArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- hosted_zone_id=hosted_zone_id,
- record_sets=record_sets,
- record_set_type=record_set_type,
- spotinst_acct_id=spotinst_acct_id,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- hosted_zone_id: Optional[pulumi.Input[str]] = None,
- record_sets: Optional[pulumi.Input[Sequence[pulumi.Input['ManagedInstanceIntegrationRoute53DomainRecordSetArgs']]]] = None,
- record_set_type: Optional[pulumi.Input[str]] = None,
- spotinst_acct_id: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if hosted_zone_id is None and 'hostedZoneId' in kwargs:
- hosted_zone_id = kwargs['hostedZoneId']
- if hosted_zone_id is None:
- raise TypeError("Missing 'hosted_zone_id' argument")
- if record_sets is None and 'recordSets' in kwargs:
- record_sets = kwargs['recordSets']
- if record_sets is None:
- raise TypeError("Missing 'record_sets' argument")
- if record_set_type is None and 'recordSetType' in kwargs:
- record_set_type = kwargs['recordSetType']
- if spotinst_acct_id is None and 'spotinstAcctId' in kwargs:
- spotinst_acct_id = kwargs['spotinstAcctId']
-
- _setter("hosted_zone_id", hosted_zone_id)
- _setter("record_sets", record_sets)
+ pulumi.set(__self__, "hosted_zone_id", hosted_zone_id)
+ pulumi.set(__self__, "record_sets", record_sets)
if record_set_type is not None:
- _setter("record_set_type", record_set_type)
+ pulumi.set(__self__, "record_set_type", record_set_type)
if spotinst_acct_id is not None:
- _setter("spotinst_acct_id", spotinst_acct_id)
+ pulumi.set(__self__, "spotinst_acct_id", spotinst_acct_id)
@property
@pulumi.getter(name="hostedZoneId")
@@ -8454,32 +6319,11 @@ def __init__(__self__, *,
name: pulumi.Input[str],
use_public_dns: Optional[pulumi.Input[bool]] = None,
use_public_ip: Optional[pulumi.Input[bool]] = None):
- ManagedInstanceIntegrationRoute53DomainRecordSetArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- use_public_dns=use_public_dns,
- use_public_ip=use_public_ip,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- use_public_dns: Optional[pulumi.Input[bool]] = None,
- use_public_ip: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
- if use_public_dns is None and 'usePublicDns' in kwargs:
- use_public_dns = kwargs['usePublicDns']
- if use_public_ip is None and 'usePublicIp' in kwargs:
- use_public_ip = kwargs['usePublicIp']
-
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if use_public_dns is not None:
- _setter("use_public_dns", use_public_dns)
+ pulumi.set(__self__, "use_public_dns", use_public_dns)
if use_public_ip is not None:
- _setter("use_public_ip", use_public_ip)
+ pulumi.set(__self__, "use_public_ip", use_public_ip)
@property
@pulumi.getter
@@ -8519,52 +6363,19 @@ def __init__(__self__, *,
balancer_id: Optional[pulumi.Input[str]] = None,
name: Optional[pulumi.Input[str]] = None,
target_set_id: Optional[pulumi.Input[str]] = None):
- ManagedInstanceLoadBalancerArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- type=type,
- arn=arn,
- auto_weight=auto_weight,
- az_awareness=az_awareness,
- balancer_id=balancer_id,
- name=name,
- target_set_id=target_set_id,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- type: Optional[pulumi.Input[str]] = None,
- arn: Optional[pulumi.Input[str]] = None,
- auto_weight: Optional[pulumi.Input[bool]] = None,
- az_awareness: Optional[pulumi.Input[bool]] = None,
- balancer_id: Optional[pulumi.Input[str]] = None,
- name: Optional[pulumi.Input[str]] = None,
- target_set_id: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if type is None:
- raise TypeError("Missing 'type' argument")
- if auto_weight is None and 'autoWeight' in kwargs:
- auto_weight = kwargs['autoWeight']
- if az_awareness is None and 'azAwareness' in kwargs:
- az_awareness = kwargs['azAwareness']
- if balancer_id is None and 'balancerId' in kwargs:
- balancer_id = kwargs['balancerId']
- if target_set_id is None and 'targetSetId' in kwargs:
- target_set_id = kwargs['targetSetId']
-
- _setter("type", type)
+ pulumi.set(__self__, "type", type)
if arn is not None:
- _setter("arn", arn)
+ pulumi.set(__self__, "arn", arn)
if auto_weight is not None:
- _setter("auto_weight", auto_weight)
+ pulumi.set(__self__, "auto_weight", auto_weight)
if az_awareness is not None:
- _setter("az_awareness", az_awareness)
+ pulumi.set(__self__, "az_awareness", az_awareness)
if balancer_id is not None:
- _setter("balancer_id", balancer_id)
+ pulumi.set(__self__, "balancer_id", balancer_id)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if target_set_id is not None:
- _setter("target_set_id", target_set_id)
+ pulumi.set(__self__, "target_set_id", target_set_id)
@property
@pulumi.getter
@@ -8634,20 +6445,7 @@ def target_set_id(self, value: Optional[pulumi.Input[str]]):
class ManagedInstanceManagedInstanceActionArgs:
def __init__(__self__, *,
type: pulumi.Input[str]):
- ManagedInstanceManagedInstanceActionArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- type=type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- type: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if type is None:
- raise TypeError("Missing 'type' argument")
-
- _setter("type", type)
+ pulumi.set(__self__, "type", type)
@property
@pulumi.getter
@@ -8665,34 +6463,11 @@ def __init__(__self__, *,
device_index: pulumi.Input[str],
associate_ipv6_address: Optional[pulumi.Input[bool]] = None,
associate_public_ip_address: Optional[pulumi.Input[bool]] = None):
- ManagedInstanceNetworkInterfaceArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- device_index=device_index,
- associate_ipv6_address=associate_ipv6_address,
- associate_public_ip_address=associate_public_ip_address,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- device_index: Optional[pulumi.Input[str]] = None,
- associate_ipv6_address: Optional[pulumi.Input[bool]] = None,
- associate_public_ip_address: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if device_index is None and 'deviceIndex' in kwargs:
- device_index = kwargs['deviceIndex']
- if device_index is None:
- raise TypeError("Missing 'device_index' argument")
- if associate_ipv6_address is None and 'associateIpv6Address' in kwargs:
- associate_ipv6_address = kwargs['associateIpv6Address']
- if associate_public_ip_address is None and 'associatePublicIpAddress' in kwargs:
- associate_public_ip_address = kwargs['associatePublicIpAddress']
-
- _setter("device_index", device_index)
+ pulumi.set(__self__, "device_index", device_index)
if associate_ipv6_address is not None:
- _setter("associate_ipv6_address", associate_ipv6_address)
+ pulumi.set(__self__, "associate_ipv6_address", associate_ipv6_address)
if associate_public_ip_address is not None:
- _setter("associate_public_ip_address", associate_public_ip_address)
+ pulumi.set(__self__, "associate_public_ip_address", associate_public_ip_address)
@property
@pulumi.getter(name="deviceIndex")
@@ -8729,39 +6504,14 @@ def __init__(__self__, *,
should_tag_enis: Optional[pulumi.Input[bool]] = None,
should_tag_snapshots: Optional[pulumi.Input[bool]] = None,
should_tag_volumes: Optional[pulumi.Input[bool]] = None):
- ManagedInstanceResourceTagSpecificationArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- should_tag_amis=should_tag_amis,
- should_tag_enis=should_tag_enis,
- should_tag_snapshots=should_tag_snapshots,
- should_tag_volumes=should_tag_volumes,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- should_tag_amis: Optional[pulumi.Input[bool]] = None,
- should_tag_enis: Optional[pulumi.Input[bool]] = None,
- should_tag_snapshots: Optional[pulumi.Input[bool]] = None,
- should_tag_volumes: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if should_tag_amis is None and 'shouldTagAmis' in kwargs:
- should_tag_amis = kwargs['shouldTagAmis']
- if should_tag_enis is None and 'shouldTagEnis' in kwargs:
- should_tag_enis = kwargs['shouldTagEnis']
- if should_tag_snapshots is None and 'shouldTagSnapshots' in kwargs:
- should_tag_snapshots = kwargs['shouldTagSnapshots']
- if should_tag_volumes is None and 'shouldTagVolumes' in kwargs:
- should_tag_volumes = kwargs['shouldTagVolumes']
-
if should_tag_amis is not None:
- _setter("should_tag_amis", should_tag_amis)
+ pulumi.set(__self__, "should_tag_amis", should_tag_amis)
if should_tag_enis is not None:
- _setter("should_tag_enis", should_tag_enis)
+ pulumi.set(__self__, "should_tag_enis", should_tag_enis)
if should_tag_snapshots is not None:
- _setter("should_tag_snapshots", should_tag_snapshots)
+ pulumi.set(__self__, "should_tag_snapshots", should_tag_snapshots)
if should_tag_volumes is not None:
- _setter("should_tag_volumes", should_tag_volumes)
+ pulumi.set(__self__, "should_tag_volumes", should_tag_volumes)
@property
@pulumi.getter(name="shouldTagAmis")
@@ -8804,22 +6554,7 @@ def should_tag_volumes(self, value: Optional[pulumi.Input[bool]]):
class ManagedInstanceRevertToSpotArgs:
def __init__(__self__, *,
perform_at: pulumi.Input[str]):
- ManagedInstanceRevertToSpotArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- perform_at=perform_at,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- perform_at: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if perform_at is None and 'performAt' in kwargs:
- perform_at = kwargs['performAt']
- if perform_at is None:
- raise TypeError("Missing 'perform_at' argument")
-
- _setter("perform_at", perform_at)
+ pulumi.set(__self__, "perform_at", perform_at)
@property
@pulumi.getter(name="performAt")
@@ -8839,44 +6574,15 @@ def __init__(__self__, *,
frequency: Optional[pulumi.Input[str]] = None,
is_enabled: Optional[pulumi.Input[bool]] = None,
start_time: Optional[pulumi.Input[str]] = None):
- ManagedInstanceScheduledTaskArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- task_type=task_type,
- cron_expression=cron_expression,
- frequency=frequency,
- is_enabled=is_enabled,
- start_time=start_time,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- task_type: Optional[pulumi.Input[str]] = None,
- cron_expression: Optional[pulumi.Input[str]] = None,
- frequency: Optional[pulumi.Input[str]] = None,
- is_enabled: Optional[pulumi.Input[bool]] = None,
- start_time: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if task_type is None and 'taskType' in kwargs:
- task_type = kwargs['taskType']
- if task_type is None:
- raise TypeError("Missing 'task_type' argument")
- if cron_expression is None and 'cronExpression' in kwargs:
- cron_expression = kwargs['cronExpression']
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
- if start_time is None and 'startTime' in kwargs:
- start_time = kwargs['startTime']
-
- _setter("task_type", task_type)
+ pulumi.set(__self__, "task_type", task_type)
if cron_expression is not None:
- _setter("cron_expression", cron_expression)
+ pulumi.set(__self__, "cron_expression", cron_expression)
if frequency is not None:
- _setter("frequency", frequency)
+ pulumi.set(__self__, "frequency", frequency)
if is_enabled is not None:
- _setter("is_enabled", is_enabled)
+ pulumi.set(__self__, "is_enabled", is_enabled)
if start_time is not None:
- _setter("start_time", start_time)
+ pulumi.set(__self__, "start_time", start_time)
@property
@pulumi.getter(name="taskType")
@@ -8929,23 +6635,10 @@ class ManagedInstanceTagArgs:
def __init__(__self__, *,
key: Optional[pulumi.Input[str]] = None,
value: Optional[pulumi.Input[str]] = None):
- ManagedInstanceTagArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if key is not None:
- _setter("key", key)
+ pulumi.set(__self__, "key", key)
if value is not None:
- _setter("value", value)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -8977,28 +6670,11 @@ def __init__(__self__, *,
:param pulumi.Input[Sequence[pulumi.Input[str]]] args: Arguments for EMR to pass to the application.
:param pulumi.Input[str] version: T he version of the application.
"""
- MrScalarApplicationArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- args=args,
- version=version,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- args: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- version: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
-
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if args is not None:
- _setter("args", args)
+ pulumi.set(__self__, "args", args)
if version is not None:
- _setter("version", version)
+ pulumi.set(__self__, "version", version)
@property
@pulumi.getter
@@ -9046,25 +6722,8 @@ def __init__(__self__, *,
:param pulumi.Input[str] bucket: S3 Bucket name for bootstrap actions.
:param pulumi.Input[str] key: S3 key for bootstrap actions.
"""
- MrScalarBootstrapActionsFileArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- bucket=bucket,
- key=key,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- bucket: Optional[pulumi.Input[str]] = None,
- key: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if bucket is None:
- raise TypeError("Missing 'bucket' argument")
- if key is None:
- raise TypeError("Missing 'key' argument")
-
- _setter("bucket", bucket)
- _setter("key", key)
+ pulumi.set(__self__, "bucket", bucket)
+ pulumi.set(__self__, "key", key)
@property
@pulumi.getter
@@ -9100,25 +6759,8 @@ def __init__(__self__, *,
:param pulumi.Input[str] bucket: S3 Bucket name for bootstrap actions.
:param pulumi.Input[str] key: S3 key for bootstrap actions.
"""
- MrScalarConfigurationsFileArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- bucket=bucket,
- key=key,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- bucket: Optional[pulumi.Input[str]] = None,
- key: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if bucket is None:
- raise TypeError("Missing 'bucket' argument")
- if key is None:
- raise TypeError("Missing 'key' argument")
-
- _setter("bucket", bucket)
- _setter("key", key)
+ pulumi.set(__self__, "bucket", bucket)
+ pulumi.set(__self__, "key", key)
@property
@pulumi.getter
@@ -9158,39 +6800,12 @@ def __init__(__self__, *,
:param pulumi.Input[int] iops: IOPS for the volume. Required in some volume types, such as io1.
:param pulumi.Input[int] volumes_per_instance: Amount of volumes per instance in the core group.
"""
- MrScalarCoreEbsBlockDeviceArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- size_in_gb=size_in_gb,
- volume_type=volume_type,
- iops=iops,
- volumes_per_instance=volumes_per_instance,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- size_in_gb: Optional[pulumi.Input[int]] = None,
- volume_type: Optional[pulumi.Input[str]] = None,
- iops: Optional[pulumi.Input[int]] = None,
- volumes_per_instance: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if size_in_gb is None and 'sizeInGb' in kwargs:
- size_in_gb = kwargs['sizeInGb']
- if size_in_gb is None:
- raise TypeError("Missing 'size_in_gb' argument")
- if volume_type is None and 'volumeType' in kwargs:
- volume_type = kwargs['volumeType']
- if volume_type is None:
- raise TypeError("Missing 'volume_type' argument")
- if volumes_per_instance is None and 'volumesPerInstance' in kwargs:
- volumes_per_instance = kwargs['volumesPerInstance']
-
- _setter("size_in_gb", size_in_gb)
- _setter("volume_type", volume_type)
+ pulumi.set(__self__, "size_in_gb", size_in_gb)
+ pulumi.set(__self__, "volume_type", volume_type)
if iops is not None:
- _setter("iops", iops)
+ pulumi.set(__self__, "iops", iops)
if volumes_per_instance is not None:
- _setter("volumes_per_instance", volumes_per_instance)
+ pulumi.set(__self__, "volumes_per_instance", volumes_per_instance)
@property
@pulumi.getter(name="sizeInGb")
@@ -9282,104 +6897,37 @@ def __init__(__self__, *,
:param pulumi.Input[str] statistic: The aggregation method of the given metric. Valid Values: `average` | `sum` | `sampleCount` | `maximum` | `minimum`
:param pulumi.Input[str] target: The number of instances to set when scale is needed.
"""
- MrScalarCoreScalingDownPolicyArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- metric_name=metric_name,
- namespace=namespace,
- policy_name=policy_name,
- threshold=threshold,
- unit=unit,
- action_type=action_type,
- adjustment=adjustment,
- cooldown=cooldown,
- dimensions=dimensions,
- evaluation_periods=evaluation_periods,
- max_target_capacity=max_target_capacity,
- maximum=maximum,
- min_target_capacity=min_target_capacity,
- minimum=minimum,
- operator=operator,
- period=period,
- statistic=statistic,
- target=target,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- metric_name: Optional[pulumi.Input[str]] = None,
- namespace: Optional[pulumi.Input[str]] = None,
- policy_name: Optional[pulumi.Input[str]] = None,
- threshold: Optional[pulumi.Input[float]] = None,
- unit: Optional[pulumi.Input[str]] = None,
- action_type: Optional[pulumi.Input[str]] = None,
- adjustment: Optional[pulumi.Input[str]] = None,
- cooldown: Optional[pulumi.Input[int]] = None,
- dimensions: Optional[pulumi.Input[Mapping[str, Any]]] = None,
- evaluation_periods: Optional[pulumi.Input[int]] = None,
- max_target_capacity: Optional[pulumi.Input[str]] = None,
- maximum: Optional[pulumi.Input[str]] = None,
- min_target_capacity: Optional[pulumi.Input[str]] = None,
- minimum: Optional[pulumi.Input[str]] = None,
- operator: Optional[pulumi.Input[str]] = None,
- period: Optional[pulumi.Input[int]] = None,
- statistic: Optional[pulumi.Input[str]] = None,
- target: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if metric_name is None and 'metricName' in kwargs:
- metric_name = kwargs['metricName']
- if metric_name is None:
- raise TypeError("Missing 'metric_name' argument")
- if namespace is None:
- raise TypeError("Missing 'namespace' argument")
- if policy_name is None and 'policyName' in kwargs:
- policy_name = kwargs['policyName']
- if policy_name is None:
- raise TypeError("Missing 'policy_name' argument")
- if threshold is None:
- raise TypeError("Missing 'threshold' argument")
- if unit is None:
- raise TypeError("Missing 'unit' argument")
- if action_type is None and 'actionType' in kwargs:
- action_type = kwargs['actionType']
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
- if max_target_capacity is None and 'maxTargetCapacity' in kwargs:
- max_target_capacity = kwargs['maxTargetCapacity']
- if min_target_capacity is None and 'minTargetCapacity' in kwargs:
- min_target_capacity = kwargs['minTargetCapacity']
-
- _setter("metric_name", metric_name)
- _setter("namespace", namespace)
- _setter("policy_name", policy_name)
- _setter("threshold", threshold)
- _setter("unit", unit)
+ pulumi.set(__self__, "metric_name", metric_name)
+ pulumi.set(__self__, "namespace", namespace)
+ pulumi.set(__self__, "policy_name", policy_name)
+ pulumi.set(__self__, "threshold", threshold)
+ pulumi.set(__self__, "unit", unit)
if action_type is not None:
- _setter("action_type", action_type)
+ pulumi.set(__self__, "action_type", action_type)
if adjustment is not None:
- _setter("adjustment", adjustment)
+ pulumi.set(__self__, "adjustment", adjustment)
if cooldown is not None:
- _setter("cooldown", cooldown)
+ pulumi.set(__self__, "cooldown", cooldown)
if dimensions is not None:
- _setter("dimensions", dimensions)
+ pulumi.set(__self__, "dimensions", dimensions)
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
if max_target_capacity is not None:
- _setter("max_target_capacity", max_target_capacity)
+ pulumi.set(__self__, "max_target_capacity", max_target_capacity)
if maximum is not None:
- _setter("maximum", maximum)
+ pulumi.set(__self__, "maximum", maximum)
if min_target_capacity is not None:
- _setter("min_target_capacity", min_target_capacity)
+ pulumi.set(__self__, "min_target_capacity", min_target_capacity)
if minimum is not None:
- _setter("minimum", minimum)
+ pulumi.set(__self__, "minimum", minimum)
if operator is not None:
- _setter("operator", operator)
+ pulumi.set(__self__, "operator", operator)
if period is not None:
- _setter("period", period)
+ pulumi.set(__self__, "period", period)
if statistic is not None:
- _setter("statistic", statistic)
+ pulumi.set(__self__, "statistic", statistic)
if target is not None:
- _setter("target", target)
+ pulumi.set(__self__, "target", target)
@property
@pulumi.getter(name="metricName")
@@ -9639,104 +7187,37 @@ def __init__(__self__, *,
:param pulumi.Input[str] statistic: The aggregation method of the given metric. Valid Values: `average` | `sum` | `sampleCount` | `maximum` | `minimum`
:param pulumi.Input[str] target: The number of instances to set when scale is needed.
"""
- MrScalarCoreScalingUpPolicyArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- metric_name=metric_name,
- namespace=namespace,
- policy_name=policy_name,
- threshold=threshold,
- unit=unit,
- action_type=action_type,
- adjustment=adjustment,
- cooldown=cooldown,
- dimensions=dimensions,
- evaluation_periods=evaluation_periods,
- max_target_capacity=max_target_capacity,
- maximum=maximum,
- min_target_capacity=min_target_capacity,
- minimum=minimum,
- operator=operator,
- period=period,
- statistic=statistic,
- target=target,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- metric_name: Optional[pulumi.Input[str]] = None,
- namespace: Optional[pulumi.Input[str]] = None,
- policy_name: Optional[pulumi.Input[str]] = None,
- threshold: Optional[pulumi.Input[float]] = None,
- unit: Optional[pulumi.Input[str]] = None,
- action_type: Optional[pulumi.Input[str]] = None,
- adjustment: Optional[pulumi.Input[str]] = None,
- cooldown: Optional[pulumi.Input[int]] = None,
- dimensions: Optional[pulumi.Input[Mapping[str, Any]]] = None,
- evaluation_periods: Optional[pulumi.Input[int]] = None,
- max_target_capacity: Optional[pulumi.Input[str]] = None,
- maximum: Optional[pulumi.Input[str]] = None,
- min_target_capacity: Optional[pulumi.Input[str]] = None,
- minimum: Optional[pulumi.Input[str]] = None,
- operator: Optional[pulumi.Input[str]] = None,
- period: Optional[pulumi.Input[int]] = None,
- statistic: Optional[pulumi.Input[str]] = None,
- target: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if metric_name is None and 'metricName' in kwargs:
- metric_name = kwargs['metricName']
- if metric_name is None:
- raise TypeError("Missing 'metric_name' argument")
- if namespace is None:
- raise TypeError("Missing 'namespace' argument")
- if policy_name is None and 'policyName' in kwargs:
- policy_name = kwargs['policyName']
- if policy_name is None:
- raise TypeError("Missing 'policy_name' argument")
- if threshold is None:
- raise TypeError("Missing 'threshold' argument")
- if unit is None:
- raise TypeError("Missing 'unit' argument")
- if action_type is None and 'actionType' in kwargs:
- action_type = kwargs['actionType']
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
- if max_target_capacity is None and 'maxTargetCapacity' in kwargs:
- max_target_capacity = kwargs['maxTargetCapacity']
- if min_target_capacity is None and 'minTargetCapacity' in kwargs:
- min_target_capacity = kwargs['minTargetCapacity']
-
- _setter("metric_name", metric_name)
- _setter("namespace", namespace)
- _setter("policy_name", policy_name)
- _setter("threshold", threshold)
- _setter("unit", unit)
+ pulumi.set(__self__, "metric_name", metric_name)
+ pulumi.set(__self__, "namespace", namespace)
+ pulumi.set(__self__, "policy_name", policy_name)
+ pulumi.set(__self__, "threshold", threshold)
+ pulumi.set(__self__, "unit", unit)
if action_type is not None:
- _setter("action_type", action_type)
+ pulumi.set(__self__, "action_type", action_type)
if adjustment is not None:
- _setter("adjustment", adjustment)
+ pulumi.set(__self__, "adjustment", adjustment)
if cooldown is not None:
- _setter("cooldown", cooldown)
+ pulumi.set(__self__, "cooldown", cooldown)
if dimensions is not None:
- _setter("dimensions", dimensions)
+ pulumi.set(__self__, "dimensions", dimensions)
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
if max_target_capacity is not None:
- _setter("max_target_capacity", max_target_capacity)
+ pulumi.set(__self__, "max_target_capacity", max_target_capacity)
if maximum is not None:
- _setter("maximum", maximum)
+ pulumi.set(__self__, "maximum", maximum)
if min_target_capacity is not None:
- _setter("min_target_capacity", min_target_capacity)
+ pulumi.set(__self__, "min_target_capacity", min_target_capacity)
if minimum is not None:
- _setter("minimum", minimum)
+ pulumi.set(__self__, "minimum", minimum)
if operator is not None:
- _setter("operator", operator)
+ pulumi.set(__self__, "operator", operator)
if period is not None:
- _setter("period", period)
+ pulumi.set(__self__, "period", period)
if statistic is not None:
- _setter("statistic", statistic)
+ pulumi.set(__self__, "statistic", statistic)
if target is not None:
- _setter("target", target)
+ pulumi.set(__self__, "target", target)
@property
@pulumi.getter(name="metricName")
@@ -9964,29 +7445,8 @@ def __init__(__self__, *,
:param pulumi.Input[str] instance_type: The type of the instance.
:param pulumi.Input[int] weighted_capacity: The weight given to the associated instance type.
"""
- MrScalarInstanceWeightArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- instance_type=instance_type,
- weighted_capacity=weighted_capacity,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- instance_type: Optional[pulumi.Input[str]] = None,
- weighted_capacity: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if instance_type is None and 'instanceType' in kwargs:
- instance_type = kwargs['instanceType']
- if instance_type is None:
- raise TypeError("Missing 'instance_type' argument")
- if weighted_capacity is None and 'weightedCapacity' in kwargs:
- weighted_capacity = kwargs['weightedCapacity']
- if weighted_capacity is None:
- raise TypeError("Missing 'weighted_capacity' argument")
-
- _setter("instance_type", instance_type)
- _setter("weighted_capacity", weighted_capacity)
+ pulumi.set(__self__, "instance_type", instance_type)
+ pulumi.set(__self__, "weighted_capacity", weighted_capacity)
@property
@pulumi.getter(name="instanceType")
@@ -10026,39 +7486,12 @@ def __init__(__self__, *,
:param pulumi.Input[int] iops: IOPS for the volume. Required in some volume types, such as io1.
:param pulumi.Input[int] volumes_per_instance: Amount of volumes per instance in the core group.
"""
- MrScalarMasterEbsBlockDeviceArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- size_in_gb=size_in_gb,
- volume_type=volume_type,
- iops=iops,
- volumes_per_instance=volumes_per_instance,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- size_in_gb: Optional[pulumi.Input[int]] = None,
- volume_type: Optional[pulumi.Input[str]] = None,
- iops: Optional[pulumi.Input[int]] = None,
- volumes_per_instance: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if size_in_gb is None and 'sizeInGb' in kwargs:
- size_in_gb = kwargs['sizeInGb']
- if size_in_gb is None:
- raise TypeError("Missing 'size_in_gb' argument")
- if volume_type is None and 'volumeType' in kwargs:
- volume_type = kwargs['volumeType']
- if volume_type is None:
- raise TypeError("Missing 'volume_type' argument")
- if volumes_per_instance is None and 'volumesPerInstance' in kwargs:
- volumes_per_instance = kwargs['volumesPerInstance']
-
- _setter("size_in_gb", size_in_gb)
- _setter("volume_type", volume_type)
+ pulumi.set(__self__, "size_in_gb", size_in_gb)
+ pulumi.set(__self__, "volume_type", volume_type)
if iops is not None:
- _setter("iops", iops)
+ pulumi.set(__self__, "iops", iops)
if volumes_per_instance is not None:
- _setter("volumes_per_instance", volumes_per_instance)
+ pulumi.set(__self__, "volumes_per_instance", volumes_per_instance)
@property
@pulumi.getter(name="sizeInGb")
@@ -10118,27 +7551,8 @@ def __init__(__self__, *,
:param pulumi.Input[int] timeout: The amount of time (minutes) after which the cluster is automatically terminated if it's still in provisioning status. Minimum: '15'.
:param pulumi.Input[str] timeout_action: The action to take if the timeout is exceeded. Valid values: `terminate`, `terminateAndRetry`.
"""
- MrScalarProvisioningTimeoutArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- timeout=timeout,
- timeout_action=timeout_action,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- timeout: Optional[pulumi.Input[int]] = None,
- timeout_action: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if timeout is None:
- raise TypeError("Missing 'timeout' argument")
- if timeout_action is None and 'timeoutAction' in kwargs:
- timeout_action = kwargs['timeoutAction']
- if timeout_action is None:
- raise TypeError("Missing 'timeout_action' argument")
-
- _setter("timeout", timeout)
- _setter("timeout_action", timeout_action)
+ pulumi.set(__self__, "timeout", timeout)
+ pulumi.set(__self__, "timeout_action", timeout_action)
@property
@pulumi.getter
@@ -10184,58 +7598,17 @@ def __init__(__self__, *,
:param pulumi.Input[str] max_capacity: New max capacity for the elastigroup.
:param pulumi.Input[str] min_capacity: New min capacity for the elastigroup.
"""
- MrScalarScheduledTaskArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cron=cron,
- instance_group_type=instance_group_type,
- task_type=task_type,
- desired_capacity=desired_capacity,
- is_enabled=is_enabled,
- max_capacity=max_capacity,
- min_capacity=min_capacity,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cron: Optional[pulumi.Input[str]] = None,
- instance_group_type: Optional[pulumi.Input[str]] = None,
- task_type: Optional[pulumi.Input[str]] = None,
- desired_capacity: Optional[pulumi.Input[str]] = None,
- is_enabled: Optional[pulumi.Input[bool]] = None,
- max_capacity: Optional[pulumi.Input[str]] = None,
- min_capacity: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cron is None:
- raise TypeError("Missing 'cron' argument")
- if instance_group_type is None and 'instanceGroupType' in kwargs:
- instance_group_type = kwargs['instanceGroupType']
- if instance_group_type is None:
- raise TypeError("Missing 'instance_group_type' argument")
- if task_type is None and 'taskType' in kwargs:
- task_type = kwargs['taskType']
- if task_type is None:
- raise TypeError("Missing 'task_type' argument")
- if desired_capacity is None and 'desiredCapacity' in kwargs:
- desired_capacity = kwargs['desiredCapacity']
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
- if max_capacity is None and 'maxCapacity' in kwargs:
- max_capacity = kwargs['maxCapacity']
- if min_capacity is None and 'minCapacity' in kwargs:
- min_capacity = kwargs['minCapacity']
-
- _setter("cron", cron)
- _setter("instance_group_type", instance_group_type)
- _setter("task_type", task_type)
+ pulumi.set(__self__, "cron", cron)
+ pulumi.set(__self__, "instance_group_type", instance_group_type)
+ pulumi.set(__self__, "task_type", task_type)
if desired_capacity is not None:
- _setter("desired_capacity", desired_capacity)
+ pulumi.set(__self__, "desired_capacity", desired_capacity)
if is_enabled is not None:
- _setter("is_enabled", is_enabled)
+ pulumi.set(__self__, "is_enabled", is_enabled)
if max_capacity is not None:
- _setter("max_capacity", max_capacity)
+ pulumi.set(__self__, "max_capacity", max_capacity)
if min_capacity is not None:
- _setter("min_capacity", min_capacity)
+ pulumi.set(__self__, "min_capacity", min_capacity)
@property
@pulumi.getter
@@ -10331,25 +7704,8 @@ def __init__(__self__, *,
:param pulumi.Input[str] bucket: S3 Bucket name for bootstrap actions.
:param pulumi.Input[str] key: S3 key for bootstrap actions.
"""
- MrScalarStepsFileArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- bucket=bucket,
- key=key,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- bucket: Optional[pulumi.Input[str]] = None,
- key: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if bucket is None:
- raise TypeError("Missing 'bucket' argument")
- if key is None:
- raise TypeError("Missing 'key' argument")
-
- _setter("bucket", bucket)
- _setter("key", key)
+ pulumi.set(__self__, "bucket", bucket)
+ pulumi.set(__self__, "key", key)
@property
@pulumi.getter
@@ -10385,25 +7741,8 @@ def __init__(__self__, *,
:param pulumi.Input[str] key: S3 key for bootstrap actions.
:param pulumi.Input[str] value: Tag value.
"""
- MrScalarTagArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -10443,39 +7782,12 @@ def __init__(__self__, *,
:param pulumi.Input[int] iops: IOPS for the volume. Required in some volume types, such as io1.
:param pulumi.Input[int] volumes_per_instance: Amount of volumes per instance in the core group.
"""
- MrScalarTaskEbsBlockDeviceArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- size_in_gb=size_in_gb,
- volume_type=volume_type,
- iops=iops,
- volumes_per_instance=volumes_per_instance,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- size_in_gb: Optional[pulumi.Input[int]] = None,
- volume_type: Optional[pulumi.Input[str]] = None,
- iops: Optional[pulumi.Input[int]] = None,
- volumes_per_instance: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if size_in_gb is None and 'sizeInGb' in kwargs:
- size_in_gb = kwargs['sizeInGb']
- if size_in_gb is None:
- raise TypeError("Missing 'size_in_gb' argument")
- if volume_type is None and 'volumeType' in kwargs:
- volume_type = kwargs['volumeType']
- if volume_type is None:
- raise TypeError("Missing 'volume_type' argument")
- if volumes_per_instance is None and 'volumesPerInstance' in kwargs:
- volumes_per_instance = kwargs['volumesPerInstance']
-
- _setter("size_in_gb", size_in_gb)
- _setter("volume_type", volume_type)
+ pulumi.set(__self__, "size_in_gb", size_in_gb)
+ pulumi.set(__self__, "volume_type", volume_type)
if iops is not None:
- _setter("iops", iops)
+ pulumi.set(__self__, "iops", iops)
if volumes_per_instance is not None:
- _setter("volumes_per_instance", volumes_per_instance)
+ pulumi.set(__self__, "volumes_per_instance", volumes_per_instance)
@property
@pulumi.getter(name="sizeInGb")
@@ -10567,104 +7879,37 @@ def __init__(__self__, *,
:param pulumi.Input[str] statistic: The aggregation method of the given metric. Valid Values: `average` | `sum` | `sampleCount` | `maximum` | `minimum`
:param pulumi.Input[str] target: The number of instances to set when scale is needed.
"""
- MrScalarTaskScalingDownPolicyArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- metric_name=metric_name,
- namespace=namespace,
- policy_name=policy_name,
- threshold=threshold,
- unit=unit,
- action_type=action_type,
- adjustment=adjustment,
- cooldown=cooldown,
- dimensions=dimensions,
- evaluation_periods=evaluation_periods,
- max_target_capacity=max_target_capacity,
- maximum=maximum,
- min_target_capacity=min_target_capacity,
- minimum=minimum,
- operator=operator,
- period=period,
- statistic=statistic,
- target=target,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- metric_name: Optional[pulumi.Input[str]] = None,
- namespace: Optional[pulumi.Input[str]] = None,
- policy_name: Optional[pulumi.Input[str]] = None,
- threshold: Optional[pulumi.Input[float]] = None,
- unit: Optional[pulumi.Input[str]] = None,
- action_type: Optional[pulumi.Input[str]] = None,
- adjustment: Optional[pulumi.Input[str]] = None,
- cooldown: Optional[pulumi.Input[int]] = None,
- dimensions: Optional[pulumi.Input[Mapping[str, Any]]] = None,
- evaluation_periods: Optional[pulumi.Input[int]] = None,
- max_target_capacity: Optional[pulumi.Input[str]] = None,
- maximum: Optional[pulumi.Input[str]] = None,
- min_target_capacity: Optional[pulumi.Input[str]] = None,
- minimum: Optional[pulumi.Input[str]] = None,
- operator: Optional[pulumi.Input[str]] = None,
- period: Optional[pulumi.Input[int]] = None,
- statistic: Optional[pulumi.Input[str]] = None,
- target: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if metric_name is None and 'metricName' in kwargs:
- metric_name = kwargs['metricName']
- if metric_name is None:
- raise TypeError("Missing 'metric_name' argument")
- if namespace is None:
- raise TypeError("Missing 'namespace' argument")
- if policy_name is None and 'policyName' in kwargs:
- policy_name = kwargs['policyName']
- if policy_name is None:
- raise TypeError("Missing 'policy_name' argument")
- if threshold is None:
- raise TypeError("Missing 'threshold' argument")
- if unit is None:
- raise TypeError("Missing 'unit' argument")
- if action_type is None and 'actionType' in kwargs:
- action_type = kwargs['actionType']
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
- if max_target_capacity is None and 'maxTargetCapacity' in kwargs:
- max_target_capacity = kwargs['maxTargetCapacity']
- if min_target_capacity is None and 'minTargetCapacity' in kwargs:
- min_target_capacity = kwargs['minTargetCapacity']
-
- _setter("metric_name", metric_name)
- _setter("namespace", namespace)
- _setter("policy_name", policy_name)
- _setter("threshold", threshold)
- _setter("unit", unit)
+ pulumi.set(__self__, "metric_name", metric_name)
+ pulumi.set(__self__, "namespace", namespace)
+ pulumi.set(__self__, "policy_name", policy_name)
+ pulumi.set(__self__, "threshold", threshold)
+ pulumi.set(__self__, "unit", unit)
if action_type is not None:
- _setter("action_type", action_type)
+ pulumi.set(__self__, "action_type", action_type)
if adjustment is not None:
- _setter("adjustment", adjustment)
+ pulumi.set(__self__, "adjustment", adjustment)
if cooldown is not None:
- _setter("cooldown", cooldown)
+ pulumi.set(__self__, "cooldown", cooldown)
if dimensions is not None:
- _setter("dimensions", dimensions)
+ pulumi.set(__self__, "dimensions", dimensions)
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
if max_target_capacity is not None:
- _setter("max_target_capacity", max_target_capacity)
+ pulumi.set(__self__, "max_target_capacity", max_target_capacity)
if maximum is not None:
- _setter("maximum", maximum)
+ pulumi.set(__self__, "maximum", maximum)
if min_target_capacity is not None:
- _setter("min_target_capacity", min_target_capacity)
+ pulumi.set(__self__, "min_target_capacity", min_target_capacity)
if minimum is not None:
- _setter("minimum", minimum)
+ pulumi.set(__self__, "minimum", minimum)
if operator is not None:
- _setter("operator", operator)
+ pulumi.set(__self__, "operator", operator)
if period is not None:
- _setter("period", period)
+ pulumi.set(__self__, "period", period)
if statistic is not None:
- _setter("statistic", statistic)
+ pulumi.set(__self__, "statistic", statistic)
if target is not None:
- _setter("target", target)
+ pulumi.set(__self__, "target", target)
@property
@pulumi.getter(name="metricName")
@@ -10924,104 +8169,37 @@ def __init__(__self__, *,
:param pulumi.Input[str] statistic: The aggregation method of the given metric. Valid Values: `average` | `sum` | `sampleCount` | `maximum` | `minimum`
:param pulumi.Input[str] target: The number of instances to set when scale is needed.
"""
- MrScalarTaskScalingUpPolicyArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- metric_name=metric_name,
- namespace=namespace,
- policy_name=policy_name,
- threshold=threshold,
- unit=unit,
- action_type=action_type,
- adjustment=adjustment,
- cooldown=cooldown,
- dimensions=dimensions,
- evaluation_periods=evaluation_periods,
- max_target_capacity=max_target_capacity,
- maximum=maximum,
- min_target_capacity=min_target_capacity,
- minimum=minimum,
- operator=operator,
- period=period,
- statistic=statistic,
- target=target,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- metric_name: Optional[pulumi.Input[str]] = None,
- namespace: Optional[pulumi.Input[str]] = None,
- policy_name: Optional[pulumi.Input[str]] = None,
- threshold: Optional[pulumi.Input[float]] = None,
- unit: Optional[pulumi.Input[str]] = None,
- action_type: Optional[pulumi.Input[str]] = None,
- adjustment: Optional[pulumi.Input[str]] = None,
- cooldown: Optional[pulumi.Input[int]] = None,
- dimensions: Optional[pulumi.Input[Mapping[str, Any]]] = None,
- evaluation_periods: Optional[pulumi.Input[int]] = None,
- max_target_capacity: Optional[pulumi.Input[str]] = None,
- maximum: Optional[pulumi.Input[str]] = None,
- min_target_capacity: Optional[pulumi.Input[str]] = None,
- minimum: Optional[pulumi.Input[str]] = None,
- operator: Optional[pulumi.Input[str]] = None,
- period: Optional[pulumi.Input[int]] = None,
- statistic: Optional[pulumi.Input[str]] = None,
- target: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if metric_name is None and 'metricName' in kwargs:
- metric_name = kwargs['metricName']
- if metric_name is None:
- raise TypeError("Missing 'metric_name' argument")
- if namespace is None:
- raise TypeError("Missing 'namespace' argument")
- if policy_name is None and 'policyName' in kwargs:
- policy_name = kwargs['policyName']
- if policy_name is None:
- raise TypeError("Missing 'policy_name' argument")
- if threshold is None:
- raise TypeError("Missing 'threshold' argument")
- if unit is None:
- raise TypeError("Missing 'unit' argument")
- if action_type is None and 'actionType' in kwargs:
- action_type = kwargs['actionType']
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
- if max_target_capacity is None and 'maxTargetCapacity' in kwargs:
- max_target_capacity = kwargs['maxTargetCapacity']
- if min_target_capacity is None and 'minTargetCapacity' in kwargs:
- min_target_capacity = kwargs['minTargetCapacity']
-
- _setter("metric_name", metric_name)
- _setter("namespace", namespace)
- _setter("policy_name", policy_name)
- _setter("threshold", threshold)
- _setter("unit", unit)
+ pulumi.set(__self__, "metric_name", metric_name)
+ pulumi.set(__self__, "namespace", namespace)
+ pulumi.set(__self__, "policy_name", policy_name)
+ pulumi.set(__self__, "threshold", threshold)
+ pulumi.set(__self__, "unit", unit)
if action_type is not None:
- _setter("action_type", action_type)
+ pulumi.set(__self__, "action_type", action_type)
if adjustment is not None:
- _setter("adjustment", adjustment)
+ pulumi.set(__self__, "adjustment", adjustment)
if cooldown is not None:
- _setter("cooldown", cooldown)
+ pulumi.set(__self__, "cooldown", cooldown)
if dimensions is not None:
- _setter("dimensions", dimensions)
+ pulumi.set(__self__, "dimensions", dimensions)
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
if max_target_capacity is not None:
- _setter("max_target_capacity", max_target_capacity)
+ pulumi.set(__self__, "max_target_capacity", max_target_capacity)
if maximum is not None:
- _setter("maximum", maximum)
+ pulumi.set(__self__, "maximum", maximum)
if min_target_capacity is not None:
- _setter("min_target_capacity", min_target_capacity)
+ pulumi.set(__self__, "min_target_capacity", min_target_capacity)
if minimum is not None:
- _setter("minimum", minimum)
+ pulumi.set(__self__, "minimum", minimum)
if operator is not None:
- _setter("operator", operator)
+ pulumi.set(__self__, "operator", operator)
if period is not None:
- _setter("period", period)
+ pulumi.set(__self__, "period", period)
if statistic is not None:
- _setter("statistic", statistic)
+ pulumi.set(__self__, "statistic", statistic)
if target is not None:
- _setter("target", target)
+ pulumi.set(__self__, "target", target)
@property
@pulumi.getter(name="metricName")
@@ -11244,20 +8422,7 @@ def target(self, value: Optional[pulumi.Input[str]]):
class MrScalarTerminationPolicyArgs:
def __init__(__self__, *,
statements: pulumi.Input[Sequence[pulumi.Input['MrScalarTerminationPolicyStatementArgs']]]):
- MrScalarTerminationPolicyArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- statements=statements,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- statements: Optional[pulumi.Input[Sequence[pulumi.Input['MrScalarTerminationPolicyStatementArgs']]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if statements is None:
- raise TypeError("Missing 'statements' argument")
-
- _setter("statements", statements)
+ pulumi.set(__self__, "statements", statements)
@property
@pulumi.getter
@@ -11290,54 +8455,19 @@ def __init__(__self__, *,
:param pulumi.Input[str] statistic: The aggregation method of the given metric. Valid Values: `average` | `sum` | `sampleCount` | `maximum` | `minimum`
:param pulumi.Input[str] unit: The unit for a given metric. Valid Values: `seconds` | `microseconds` | `milliseconds` | `bytes` | `kilobytes` | `megabytes` | `gigabytes` | `terabytes` | `bits` | `kilobits` | `megabits` | `gigabits` | `terabits` | `percent` | `count` | `bytes/second` | `kilobytes/second` | `megabytes/second` | `gigabytes/second` | `terabytes/second` | `bits/second` | `kilobits/second` | `megabits/second` | `gigabits/second` | `terabits/second` | `count/second` | `none`
"""
- MrScalarTerminationPolicyStatementArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- metric_name=metric_name,
- namespace=namespace,
- threshold=threshold,
- evaluation_periods=evaluation_periods,
- operator=operator,
- period=period,
- statistic=statistic,
- unit=unit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- metric_name: Optional[pulumi.Input[str]] = None,
- namespace: Optional[pulumi.Input[str]] = None,
- threshold: Optional[pulumi.Input[float]] = None,
- evaluation_periods: Optional[pulumi.Input[int]] = None,
- operator: Optional[pulumi.Input[str]] = None,
- period: Optional[pulumi.Input[int]] = None,
- statistic: Optional[pulumi.Input[str]] = None,
- unit: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if metric_name is None and 'metricName' in kwargs:
- metric_name = kwargs['metricName']
- if metric_name is None:
- raise TypeError("Missing 'metric_name' argument")
- if namespace is None:
- raise TypeError("Missing 'namespace' argument")
- if threshold is None:
- raise TypeError("Missing 'threshold' argument")
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
-
- _setter("metric_name", metric_name)
- _setter("namespace", namespace)
- _setter("threshold", threshold)
+ pulumi.set(__self__, "metric_name", metric_name)
+ pulumi.set(__self__, "namespace", namespace)
+ pulumi.set(__self__, "threshold", threshold)
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
if operator is not None:
- _setter("operator", operator)
+ pulumi.set(__self__, "operator", operator)
if period is not None:
- _setter("period", period)
+ pulumi.set(__self__, "period", period)
if statistic is not None:
- _setter("statistic", statistic)
+ pulumi.set(__self__, "statistic", statistic)
if unit is not None:
- _setter("unit", unit)
+ pulumi.set(__self__, "unit", unit)
@property
@pulumi.getter(name="metricName")
@@ -11448,69 +8578,24 @@ def __init__(__self__, *,
enable_automatic_and_manual_headroom: Optional[pulumi.Input[bool]] = None,
extended_resource_definitions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
resource_limits: Optional[pulumi.Input['OceanAutoscalerResourceLimitsArgs']] = None):
- OceanAutoscalerArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- auto_headroom_percentage=auto_headroom_percentage,
- autoscale_cooldown=autoscale_cooldown,
- autoscale_down=autoscale_down,
- autoscale_headroom=autoscale_headroom,
- autoscale_is_auto_config=autoscale_is_auto_config,
- autoscale_is_enabled=autoscale_is_enabled,
- enable_automatic_and_manual_headroom=enable_automatic_and_manual_headroom,
- extended_resource_definitions=extended_resource_definitions,
- resource_limits=resource_limits,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- auto_headroom_percentage: Optional[pulumi.Input[int]] = None,
- autoscale_cooldown: Optional[pulumi.Input[int]] = None,
- autoscale_down: Optional[pulumi.Input['OceanAutoscalerAutoscaleDownArgs']] = None,
- autoscale_headroom: Optional[pulumi.Input['OceanAutoscalerAutoscaleHeadroomArgs']] = None,
- autoscale_is_auto_config: Optional[pulumi.Input[bool]] = None,
- autoscale_is_enabled: Optional[pulumi.Input[bool]] = None,
- enable_automatic_and_manual_headroom: Optional[pulumi.Input[bool]] = None,
- extended_resource_definitions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- resource_limits: Optional[pulumi.Input['OceanAutoscalerResourceLimitsArgs']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if auto_headroom_percentage is None and 'autoHeadroomPercentage' in kwargs:
- auto_headroom_percentage = kwargs['autoHeadroomPercentage']
- if autoscale_cooldown is None and 'autoscaleCooldown' in kwargs:
- autoscale_cooldown = kwargs['autoscaleCooldown']
- if autoscale_down is None and 'autoscaleDown' in kwargs:
- autoscale_down = kwargs['autoscaleDown']
- if autoscale_headroom is None and 'autoscaleHeadroom' in kwargs:
- autoscale_headroom = kwargs['autoscaleHeadroom']
- if autoscale_is_auto_config is None and 'autoscaleIsAutoConfig' in kwargs:
- autoscale_is_auto_config = kwargs['autoscaleIsAutoConfig']
- if autoscale_is_enabled is None and 'autoscaleIsEnabled' in kwargs:
- autoscale_is_enabled = kwargs['autoscaleIsEnabled']
- if enable_automatic_and_manual_headroom is None and 'enableAutomaticAndManualHeadroom' in kwargs:
- enable_automatic_and_manual_headroom = kwargs['enableAutomaticAndManualHeadroom']
- if extended_resource_definitions is None and 'extendedResourceDefinitions' in kwargs:
- extended_resource_definitions = kwargs['extendedResourceDefinitions']
- if resource_limits is None and 'resourceLimits' in kwargs:
- resource_limits = kwargs['resourceLimits']
-
if auto_headroom_percentage is not None:
- _setter("auto_headroom_percentage", auto_headroom_percentage)
+ pulumi.set(__self__, "auto_headroom_percentage", auto_headroom_percentage)
if autoscale_cooldown is not None:
- _setter("autoscale_cooldown", autoscale_cooldown)
+ pulumi.set(__self__, "autoscale_cooldown", autoscale_cooldown)
if autoscale_down is not None:
- _setter("autoscale_down", autoscale_down)
+ pulumi.set(__self__, "autoscale_down", autoscale_down)
if autoscale_headroom is not None:
- _setter("autoscale_headroom", autoscale_headroom)
+ pulumi.set(__self__, "autoscale_headroom", autoscale_headroom)
if autoscale_is_auto_config is not None:
- _setter("autoscale_is_auto_config", autoscale_is_auto_config)
+ pulumi.set(__self__, "autoscale_is_auto_config", autoscale_is_auto_config)
if autoscale_is_enabled is not None:
- _setter("autoscale_is_enabled", autoscale_is_enabled)
+ pulumi.set(__self__, "autoscale_is_enabled", autoscale_is_enabled)
if enable_automatic_and_manual_headroom is not None:
- _setter("enable_automatic_and_manual_headroom", enable_automatic_and_manual_headroom)
+ pulumi.set(__self__, "enable_automatic_and_manual_headroom", enable_automatic_and_manual_headroom)
if extended_resource_definitions is not None:
- _setter("extended_resource_definitions", extended_resource_definitions)
+ pulumi.set(__self__, "extended_resource_definitions", extended_resource_definitions)
if resource_limits is not None:
- _setter("resource_limits", resource_limits)
+ pulumi.set(__self__, "resource_limits", resource_limits)
@property
@pulumi.getter(name="autoHeadroomPercentage")
@@ -11599,27 +8684,10 @@ class OceanAutoscalerAutoscaleDownArgs:
def __init__(__self__, *,
evaluation_periods: Optional[pulumi.Input[int]] = None,
max_scale_down_percentage: Optional[pulumi.Input[float]] = None):
- OceanAutoscalerAutoscaleDownArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- evaluation_periods=evaluation_periods,
- max_scale_down_percentage=max_scale_down_percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- evaluation_periods: Optional[pulumi.Input[int]] = None,
- max_scale_down_percentage: Optional[pulumi.Input[float]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
- if max_scale_down_percentage is None and 'maxScaleDownPercentage' in kwargs:
- max_scale_down_percentage = kwargs['maxScaleDownPercentage']
-
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
if max_scale_down_percentage is not None:
- _setter("max_scale_down_percentage", max_scale_down_percentage)
+ pulumi.set(__self__, "max_scale_down_percentage", max_scale_down_percentage)
@property
@pulumi.getter(name="evaluationPeriods")
@@ -11647,39 +8715,14 @@ def __init__(__self__, *,
gpu_per_unit: Optional[pulumi.Input[int]] = None,
memory_per_unit: Optional[pulumi.Input[int]] = None,
num_of_units: Optional[pulumi.Input[int]] = None):
- OceanAutoscalerAutoscaleHeadroomArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cpu_per_unit=cpu_per_unit,
- gpu_per_unit=gpu_per_unit,
- memory_per_unit=memory_per_unit,
- num_of_units=num_of_units,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cpu_per_unit: Optional[pulumi.Input[int]] = None,
- gpu_per_unit: Optional[pulumi.Input[int]] = None,
- memory_per_unit: Optional[pulumi.Input[int]] = None,
- num_of_units: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cpu_per_unit is None and 'cpuPerUnit' in kwargs:
- cpu_per_unit = kwargs['cpuPerUnit']
- if gpu_per_unit is None and 'gpuPerUnit' in kwargs:
- gpu_per_unit = kwargs['gpuPerUnit']
- if memory_per_unit is None and 'memoryPerUnit' in kwargs:
- memory_per_unit = kwargs['memoryPerUnit']
- if num_of_units is None and 'numOfUnits' in kwargs:
- num_of_units = kwargs['numOfUnits']
-
if cpu_per_unit is not None:
- _setter("cpu_per_unit", cpu_per_unit)
+ pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
if gpu_per_unit is not None:
- _setter("gpu_per_unit", gpu_per_unit)
+ pulumi.set(__self__, "gpu_per_unit", gpu_per_unit)
if memory_per_unit is not None:
- _setter("memory_per_unit", memory_per_unit)
+ pulumi.set(__self__, "memory_per_unit", memory_per_unit)
if num_of_units is not None:
- _setter("num_of_units", num_of_units)
+ pulumi.set(__self__, "num_of_units", num_of_units)
@property
@pulumi.getter(name="cpuPerUnit")
@@ -11727,27 +8770,10 @@ def __init__(__self__, *,
:param pulumi.Input[int] max_memory_gib: Maximum amount of Memory (GiB).
:param pulumi.Input[int] max_vcpu: Maximum number of vcpus available.
"""
- OceanAutoscalerResourceLimitsArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- max_memory_gib=max_memory_gib,
- max_vcpu=max_vcpu,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- max_memory_gib: Optional[pulumi.Input[int]] = None,
- max_vcpu: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if max_memory_gib is None and 'maxMemoryGib' in kwargs:
- max_memory_gib = kwargs['maxMemoryGib']
- if max_vcpu is None and 'maxVcpu' in kwargs:
- max_vcpu = kwargs['maxVcpu']
-
if max_memory_gib is not None:
- _setter("max_memory_gib", max_memory_gib)
+ pulumi.set(__self__, "max_memory_gib", max_memory_gib)
if max_vcpu is not None:
- _setter("max_vcpu", max_vcpu)
+ pulumi.set(__self__, "max_vcpu", max_vcpu)
@property
@pulumi.getter(name="maxMemoryGib")
@@ -11783,25 +8809,10 @@ def __init__(__self__, *,
:param pulumi.Input[str] device_name: String. Set device name. (Example: `/dev/xvda`).
:param pulumi.Input['OceanBlockDeviceMappingEbsArgs'] ebs: Object. Set Elastic Block Store properties .
"""
- OceanBlockDeviceMappingArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- device_name=device_name,
- ebs=ebs,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- device_name: Optional[pulumi.Input[str]] = None,
- ebs: Optional[pulumi.Input['OceanBlockDeviceMappingEbsArgs']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if device_name is None and 'deviceName' in kwargs:
- device_name = kwargs['deviceName']
-
if device_name is not None:
- _setter("device_name", device_name)
+ pulumi.set(__self__, "device_name", device_name)
if ebs is not None:
- _setter("ebs", ebs)
+ pulumi.set(__self__, "ebs", ebs)
@property
@pulumi.getter(name="deviceName")
@@ -11853,69 +8864,26 @@ def __init__(__self__, *,
:param pulumi.Input[int] volume_size: Int. The size, in GB of the volume.
:param pulumi.Input[str] volume_type: String. The type of the volume. (Example: `gp2`).
"""
- OceanBlockDeviceMappingEbsArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- delete_on_termination=delete_on_termination,
- dynamic_iops=dynamic_iops,
- dynamic_volume_size=dynamic_volume_size,
- encrypted=encrypted,
- iops=iops,
- kms_key_id=kms_key_id,
- snapshot_id=snapshot_id,
- throughput=throughput,
- volume_size=volume_size,
- volume_type=volume_type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- delete_on_termination: Optional[pulumi.Input[bool]] = None,
- dynamic_iops: Optional[pulumi.Input['OceanBlockDeviceMappingEbsDynamicIopsArgs']] = None,
- dynamic_volume_size: Optional[pulumi.Input['OceanBlockDeviceMappingEbsDynamicVolumeSizeArgs']] = None,
- encrypted: Optional[pulumi.Input[bool]] = None,
- iops: Optional[pulumi.Input[int]] = None,
- kms_key_id: Optional[pulumi.Input[str]] = None,
- snapshot_id: Optional[pulumi.Input[str]] = None,
- throughput: Optional[pulumi.Input[int]] = None,
- volume_size: Optional[pulumi.Input[int]] = None,
- volume_type: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if delete_on_termination is None and 'deleteOnTermination' in kwargs:
- delete_on_termination = kwargs['deleteOnTermination']
- if dynamic_iops is None and 'dynamicIops' in kwargs:
- dynamic_iops = kwargs['dynamicIops']
- if dynamic_volume_size is None and 'dynamicVolumeSize' in kwargs:
- dynamic_volume_size = kwargs['dynamicVolumeSize']
- if kms_key_id is None and 'kmsKeyId' in kwargs:
- kms_key_id = kwargs['kmsKeyId']
- if snapshot_id is None and 'snapshotId' in kwargs:
- snapshot_id = kwargs['snapshotId']
- if volume_size is None and 'volumeSize' in kwargs:
- volume_size = kwargs['volumeSize']
- if volume_type is None and 'volumeType' in kwargs:
- volume_type = kwargs['volumeType']
-
if delete_on_termination is not None:
- _setter("delete_on_termination", delete_on_termination)
+ pulumi.set(__self__, "delete_on_termination", delete_on_termination)
if dynamic_iops is not None:
- _setter("dynamic_iops", dynamic_iops)
+ pulumi.set(__self__, "dynamic_iops", dynamic_iops)
if dynamic_volume_size is not None:
- _setter("dynamic_volume_size", dynamic_volume_size)
+ pulumi.set(__self__, "dynamic_volume_size", dynamic_volume_size)
if encrypted is not None:
- _setter("encrypted", encrypted)
+ pulumi.set(__self__, "encrypted", encrypted)
if iops is not None:
- _setter("iops", iops)
+ pulumi.set(__self__, "iops", iops)
if kms_key_id is not None:
- _setter("kms_key_id", kms_key_id)
+ pulumi.set(__self__, "kms_key_id", kms_key_id)
if snapshot_id is not None:
- _setter("snapshot_id", snapshot_id)
+ pulumi.set(__self__, "snapshot_id", snapshot_id)
if throughput is not None:
- _setter("throughput", throughput)
+ pulumi.set(__self__, "throughput", throughput)
if volume_size is not None:
- _setter("volume_size", volume_size)
+ pulumi.set(__self__, "volume_size", volume_size)
if volume_type is not None:
- _setter("volume_type", volume_type)
+ pulumi.set(__self__, "volume_type", volume_type)
@property
@pulumi.getter(name="deleteOnTermination")
@@ -12048,34 +9016,9 @@ def __init__(__self__, *,
:param pulumi.Input[int] base_size: Initial size for IOPS.
:param pulumi.Input[int] size_per_resource_unit: Additional size per resource unit (in IOPS). (Example: `baseSize=50`, `sizePerResourceUnit=20`, and an instance with 2 CPU is launched; its IOPS size will be: 90).
"""
- OceanBlockDeviceMappingEbsDynamicIopsArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- base_size=base_size,
- resource=resource,
- size_per_resource_unit=size_per_resource_unit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- base_size: Optional[pulumi.Input[int]] = None,
- resource: Optional[pulumi.Input[str]] = None,
- size_per_resource_unit: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if base_size is None and 'baseSize' in kwargs:
- base_size = kwargs['baseSize']
- if base_size is None:
- raise TypeError("Missing 'base_size' argument")
- if resource is None:
- raise TypeError("Missing 'resource' argument")
- if size_per_resource_unit is None and 'sizePerResourceUnit' in kwargs:
- size_per_resource_unit = kwargs['sizePerResourceUnit']
- if size_per_resource_unit is None:
- raise TypeError("Missing 'size_per_resource_unit' argument")
-
- _setter("base_size", base_size)
- _setter("resource", resource)
- _setter("size_per_resource_unit", size_per_resource_unit)
+ pulumi.set(__self__, "base_size", base_size)
+ pulumi.set(__self__, "resource", resource)
+ pulumi.set(__self__, "size_per_resource_unit", size_per_resource_unit)
@property
@pulumi.getter(name="baseSize")
@@ -12121,34 +9064,9 @@ def __init__(__self__, *,
:param pulumi.Input[int] base_size: Initial size for IOPS.
:param pulumi.Input[int] size_per_resource_unit: Additional size per resource unit (in IOPS). (Example: `baseSize=50`, `sizePerResourceUnit=20`, and an instance with 2 CPU is launched; its IOPS size will be: 90).
"""
- OceanBlockDeviceMappingEbsDynamicVolumeSizeArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- base_size=base_size,
- resource=resource,
- size_per_resource_unit=size_per_resource_unit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- base_size: Optional[pulumi.Input[int]] = None,
- resource: Optional[pulumi.Input[str]] = None,
- size_per_resource_unit: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if base_size is None and 'baseSize' in kwargs:
- base_size = kwargs['baseSize']
- if base_size is None:
- raise TypeError("Missing 'base_size' argument")
- if resource is None:
- raise TypeError("Missing 'resource' argument")
- if size_per_resource_unit is None and 'sizePerResourceUnit' in kwargs:
- size_per_resource_unit = kwargs['sizePerResourceUnit']
- if size_per_resource_unit is None:
- raise TypeError("Missing 'size_per_resource_unit' argument")
-
- _setter("base_size", base_size)
- _setter("resource", resource)
- _setter("size_per_resource_unit", size_per_resource_unit)
+ pulumi.set(__self__, "base_size", base_size)
+ pulumi.set(__self__, "resource", resource)
+ pulumi.set(__self__, "size_per_resource_unit", size_per_resource_unit)
@property
@pulumi.getter(name="baseSize")
@@ -12191,21 +9109,8 @@ def __init__(__self__, *,
"""
:param pulumi.Input[str] availability_vs_cost: You can control the approach that Ocean takes while launching nodes by configuring this value. Possible values: `costOriented`,`balanced`,`cheapest`.
"""
- OceanClusterOrientationArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- availability_vs_cost=availability_vs_cost,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- availability_vs_cost: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if availability_vs_cost is None and 'availabilityVsCost' in kwargs:
- availability_vs_cost = kwargs['availabilityVsCost']
-
if availability_vs_cost is not None:
- _setter("availability_vs_cost", availability_vs_cost)
+ pulumi.set(__self__, "availability_vs_cost", availability_vs_cost)
@property
@pulumi.getter(name="availabilityVsCost")
@@ -12263,123 +9168,44 @@ def __init__(__self__, *,
:param pulumi.Input[Sequence[pulumi.Input[str]]] root_device_types: The filtered instance types will have a root device types from this list.
:param pulumi.Input[Sequence[pulumi.Input[str]]] virtualization_types: The filtered instance types will support at least one of the virtualization types from this list.
"""
- OceanFiltersArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- architectures=architectures,
- categories=categories,
- disk_types=disk_types,
- exclude_families=exclude_families,
- exclude_metal=exclude_metal,
- hypervisors=hypervisors,
- include_families=include_families,
- is_ena_supported=is_ena_supported,
- max_gpu=max_gpu,
- max_memory_gib=max_memory_gib,
- max_network_performance=max_network_performance,
- max_vcpu=max_vcpu,
- min_enis=min_enis,
- min_gpu=min_gpu,
- min_memory_gib=min_memory_gib,
- min_network_performance=min_network_performance,
- min_vcpu=min_vcpu,
- root_device_types=root_device_types,
- virtualization_types=virtualization_types,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- architectures: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- categories: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- disk_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- exclude_families: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- exclude_metal: Optional[pulumi.Input[bool]] = None,
- hypervisors: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- include_families: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- is_ena_supported: Optional[pulumi.Input[str]] = None,
- max_gpu: Optional[pulumi.Input[int]] = None,
- max_memory_gib: Optional[pulumi.Input[float]] = None,
- max_network_performance: Optional[pulumi.Input[int]] = None,
- max_vcpu: Optional[pulumi.Input[int]] = None,
- min_enis: Optional[pulumi.Input[int]] = None,
- min_gpu: Optional[pulumi.Input[int]] = None,
- min_memory_gib: Optional[pulumi.Input[float]] = None,
- min_network_performance: Optional[pulumi.Input[int]] = None,
- min_vcpu: Optional[pulumi.Input[int]] = None,
- root_device_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- virtualization_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if disk_types is None and 'diskTypes' in kwargs:
- disk_types = kwargs['diskTypes']
- if exclude_families is None and 'excludeFamilies' in kwargs:
- exclude_families = kwargs['excludeFamilies']
- if exclude_metal is None and 'excludeMetal' in kwargs:
- exclude_metal = kwargs['excludeMetal']
- if include_families is None and 'includeFamilies' in kwargs:
- include_families = kwargs['includeFamilies']
- if is_ena_supported is None and 'isEnaSupported' in kwargs:
- is_ena_supported = kwargs['isEnaSupported']
- if max_gpu is None and 'maxGpu' in kwargs:
- max_gpu = kwargs['maxGpu']
- if max_memory_gib is None and 'maxMemoryGib' in kwargs:
- max_memory_gib = kwargs['maxMemoryGib']
- if max_network_performance is None and 'maxNetworkPerformance' in kwargs:
- max_network_performance = kwargs['maxNetworkPerformance']
- if max_vcpu is None and 'maxVcpu' in kwargs:
- max_vcpu = kwargs['maxVcpu']
- if min_enis is None and 'minEnis' in kwargs:
- min_enis = kwargs['minEnis']
- if min_gpu is None and 'minGpu' in kwargs:
- min_gpu = kwargs['minGpu']
- if min_memory_gib is None and 'minMemoryGib' in kwargs:
- min_memory_gib = kwargs['minMemoryGib']
- if min_network_performance is None and 'minNetworkPerformance' in kwargs:
- min_network_performance = kwargs['minNetworkPerformance']
- if min_vcpu is None and 'minVcpu' in kwargs:
- min_vcpu = kwargs['minVcpu']
- if root_device_types is None and 'rootDeviceTypes' in kwargs:
- root_device_types = kwargs['rootDeviceTypes']
- if virtualization_types is None and 'virtualizationTypes' in kwargs:
- virtualization_types = kwargs['virtualizationTypes']
-
if architectures is not None:
- _setter("architectures", architectures)
+ pulumi.set(__self__, "architectures", architectures)
if categories is not None:
- _setter("categories", categories)
+ pulumi.set(__self__, "categories", categories)
if disk_types is not None:
- _setter("disk_types", disk_types)
+ pulumi.set(__self__, "disk_types", disk_types)
if exclude_families is not None:
- _setter("exclude_families", exclude_families)
+ pulumi.set(__self__, "exclude_families", exclude_families)
if exclude_metal is not None:
- _setter("exclude_metal", exclude_metal)
+ pulumi.set(__self__, "exclude_metal", exclude_metal)
if hypervisors is not None:
- _setter("hypervisors", hypervisors)
+ pulumi.set(__self__, "hypervisors", hypervisors)
if include_families is not None:
- _setter("include_families", include_families)
+ pulumi.set(__self__, "include_families", include_families)
if is_ena_supported is not None:
- _setter("is_ena_supported", is_ena_supported)
+ pulumi.set(__self__, "is_ena_supported", is_ena_supported)
if max_gpu is not None:
- _setter("max_gpu", max_gpu)
+ pulumi.set(__self__, "max_gpu", max_gpu)
if max_memory_gib is not None:
- _setter("max_memory_gib", max_memory_gib)
+ pulumi.set(__self__, "max_memory_gib", max_memory_gib)
if max_network_performance is not None:
- _setter("max_network_performance", max_network_performance)
+ pulumi.set(__self__, "max_network_performance", max_network_performance)
if max_vcpu is not None:
- _setter("max_vcpu", max_vcpu)
+ pulumi.set(__self__, "max_vcpu", max_vcpu)
if min_enis is not None:
- _setter("min_enis", min_enis)
+ pulumi.set(__self__, "min_enis", min_enis)
if min_gpu is not None:
- _setter("min_gpu", min_gpu)
+ pulumi.set(__self__, "min_gpu", min_gpu)
if min_memory_gib is not None:
- _setter("min_memory_gib", min_memory_gib)
+ pulumi.set(__self__, "min_memory_gib", min_memory_gib)
if min_network_performance is not None:
- _setter("min_network_performance", min_network_performance)
+ pulumi.set(__self__, "min_network_performance", min_network_performance)
if min_vcpu is not None:
- _setter("min_vcpu", min_vcpu)
+ pulumi.set(__self__, "min_vcpu", min_vcpu)
if root_device_types is not None:
- _setter("root_device_types", root_device_types)
+ pulumi.set(__self__, "root_device_types", root_device_types)
if virtualization_types is not None:
- _setter("virtualization_types", virtualization_types)
+ pulumi.set(__self__, "virtualization_types", virtualization_types)
@property
@pulumi.getter
@@ -12619,28 +9445,9 @@ def __init__(__self__, *,
:param pulumi.Input[str] http_tokens: Determines if a signed token is required or not. Valid values: `optional` or `required`.
:param pulumi.Input[int] http_put_response_hop_limit: An integer from 1 through 64. The desired HTTP PUT response hop limit for instance metadata requests. The larger the number, the further the instance metadata requests can travel.
"""
- OceanInstanceMetadataOptionsArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- http_tokens=http_tokens,
- http_put_response_hop_limit=http_put_response_hop_limit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- http_tokens: Optional[pulumi.Input[str]] = None,
- http_put_response_hop_limit: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if http_tokens is None and 'httpTokens' in kwargs:
- http_tokens = kwargs['httpTokens']
- if http_tokens is None:
- raise TypeError("Missing 'http_tokens' argument")
- if http_put_response_hop_limit is None and 'httpPutResponseHopLimit' in kwargs:
- http_put_response_hop_limit = kwargs['httpPutResponseHopLimit']
-
- _setter("http_tokens", http_tokens)
+ pulumi.set(__self__, "http_tokens", http_tokens)
if http_put_response_hop_limit is not None:
- _setter("http_put_response_hop_limit", http_put_response_hop_limit)
+ pulumi.set(__self__, "http_put_response_hop_limit", http_put_response_hop_limit)
@property
@pulumi.getter(name="httpTokens")
@@ -12674,21 +9481,8 @@ def __init__(__self__, *,
"""
:param pulumi.Input[float] max_scale_down_percentage: The maximum percentage allowed to scale down in a single scaling action on the nodes running in a specific VNG. Allowed only if maxScaleDownPercentage is set to null at the cluster level. Number between [0.1-100].
"""
- OceanLaunchSpecAutoscaleDownArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- max_scale_down_percentage=max_scale_down_percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- max_scale_down_percentage: Optional[pulumi.Input[float]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if max_scale_down_percentage is None and 'maxScaleDownPercentage' in kwargs:
- max_scale_down_percentage = kwargs['maxScaleDownPercentage']
-
if max_scale_down_percentage is not None:
- _setter("max_scale_down_percentage", max_scale_down_percentage)
+ pulumi.set(__self__, "max_scale_down_percentage", max_scale_down_percentage)
@property
@pulumi.getter(name="maxScaleDownPercentage")
@@ -12716,40 +9510,13 @@ def __init__(__self__, *,
:param pulumi.Input[int] gpu_per_unit: Optionally configure the number of GPUS to allocate for each headroom unit.
:param pulumi.Input[int] memory_per_unit: Optionally configure the amount of memory (MiB) to allocate for each headroom unit.
"""
- OceanLaunchSpecAutoscaleHeadroomArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- num_of_units=num_of_units,
- cpu_per_unit=cpu_per_unit,
- gpu_per_unit=gpu_per_unit,
- memory_per_unit=memory_per_unit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- num_of_units: Optional[pulumi.Input[int]] = None,
- cpu_per_unit: Optional[pulumi.Input[int]] = None,
- gpu_per_unit: Optional[pulumi.Input[int]] = None,
- memory_per_unit: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if num_of_units is None and 'numOfUnits' in kwargs:
- num_of_units = kwargs['numOfUnits']
- if num_of_units is None:
- raise TypeError("Missing 'num_of_units' argument")
- if cpu_per_unit is None and 'cpuPerUnit' in kwargs:
- cpu_per_unit = kwargs['cpuPerUnit']
- if gpu_per_unit is None and 'gpuPerUnit' in kwargs:
- gpu_per_unit = kwargs['gpuPerUnit']
- if memory_per_unit is None and 'memoryPerUnit' in kwargs:
- memory_per_unit = kwargs['memoryPerUnit']
-
- _setter("num_of_units", num_of_units)
+ pulumi.set(__self__, "num_of_units", num_of_units)
if cpu_per_unit is not None:
- _setter("cpu_per_unit", cpu_per_unit)
+ pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
if gpu_per_unit is not None:
- _setter("gpu_per_unit", gpu_per_unit)
+ pulumi.set(__self__, "gpu_per_unit", gpu_per_unit)
if memory_per_unit is not None:
- _setter("memory_per_unit", memory_per_unit)
+ pulumi.set(__self__, "memory_per_unit", memory_per_unit)
@property
@pulumi.getter(name="numOfUnits")
@@ -12807,21 +9574,8 @@ def __init__(__self__, *,
"""
:param pulumi.Input[int] auto_headroom_percentage: Number between 0-200 to control the headroom % of the specific Virtual Node Group. Effective when cluster.autoScaler.headroom.automatic.`is_enabled` = true is set on the Ocean cluster.
"""
- OceanLaunchSpecAutoscaleHeadroomsAutomaticArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- auto_headroom_percentage=auto_headroom_percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- auto_headroom_percentage: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if auto_headroom_percentage is None and 'autoHeadroomPercentage' in kwargs:
- auto_headroom_percentage = kwargs['autoHeadroomPercentage']
-
if auto_headroom_percentage is not None:
- _setter("auto_headroom_percentage", auto_headroom_percentage)
+ pulumi.set(__self__, "auto_headroom_percentage", auto_headroom_percentage)
@property
@pulumi.getter(name="autoHeadroomPercentage")
@@ -12848,37 +9602,14 @@ def __init__(__self__, *,
:param pulumi.Input['OceanLaunchSpecBlockDeviceMappingEbsArgs'] ebs: Object. Set Elastic Block Store properties .
:param pulumi.Input[str] no_device: String. Suppresses the specified device included in the block device mapping of the AMI.
"""
- OceanLaunchSpecBlockDeviceMappingArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- device_name=device_name,
- ebs=ebs,
- no_device=no_device,
- virtual_name=virtual_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- device_name: Optional[pulumi.Input[str]] = None,
- ebs: Optional[pulumi.Input['OceanLaunchSpecBlockDeviceMappingEbsArgs']] = None,
- no_device: Optional[pulumi.Input[str]] = None,
- virtual_name: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if device_name is None and 'deviceName' in kwargs:
- device_name = kwargs['deviceName']
- if no_device is None and 'noDevice' in kwargs:
- no_device = kwargs['noDevice']
- if virtual_name is None and 'virtualName' in kwargs:
- virtual_name = kwargs['virtualName']
-
if device_name is not None:
- _setter("device_name", device_name)
+ pulumi.set(__self__, "device_name", device_name)
if ebs is not None:
- _setter("ebs", ebs)
+ pulumi.set(__self__, "ebs", ebs)
if no_device is not None:
- _setter("no_device", no_device)
+ pulumi.set(__self__, "no_device", no_device)
if virtual_name is not None:
- _setter("virtual_name", virtual_name)
+ pulumi.set(__self__, "virtual_name", virtual_name)
@property
@pulumi.getter(name="deviceName")
@@ -12949,63 +9680,24 @@ def __init__(__self__, *,
:param pulumi.Input[int] volume_size: Int. The size, in GB of the volume.
:param pulumi.Input[str] volume_type: String. The type of the volume. (Example: `gp2`).
"""
- OceanLaunchSpecBlockDeviceMappingEbsArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- delete_on_termination=delete_on_termination,
- dynamic_volume_size=dynamic_volume_size,
- encrypted=encrypted,
- iops=iops,
- kms_key_id=kms_key_id,
- snapshot_id=snapshot_id,
- throughput=throughput,
- volume_size=volume_size,
- volume_type=volume_type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- delete_on_termination: Optional[pulumi.Input[bool]] = None,
- dynamic_volume_size: Optional[pulumi.Input['OceanLaunchSpecBlockDeviceMappingEbsDynamicVolumeSizeArgs']] = None,
- encrypted: Optional[pulumi.Input[bool]] = None,
- iops: Optional[pulumi.Input[int]] = None,
- kms_key_id: Optional[pulumi.Input[str]] = None,
- snapshot_id: Optional[pulumi.Input[str]] = None,
- throughput: Optional[pulumi.Input[int]] = None,
- volume_size: Optional[pulumi.Input[int]] = None,
- volume_type: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if delete_on_termination is None and 'deleteOnTermination' in kwargs:
- delete_on_termination = kwargs['deleteOnTermination']
- if dynamic_volume_size is None and 'dynamicVolumeSize' in kwargs:
- dynamic_volume_size = kwargs['dynamicVolumeSize']
- if kms_key_id is None and 'kmsKeyId' in kwargs:
- kms_key_id = kwargs['kmsKeyId']
- if snapshot_id is None and 'snapshotId' in kwargs:
- snapshot_id = kwargs['snapshotId']
- if volume_size is None and 'volumeSize' in kwargs:
- volume_size = kwargs['volumeSize']
- if volume_type is None and 'volumeType' in kwargs:
- volume_type = kwargs['volumeType']
-
if delete_on_termination is not None:
- _setter("delete_on_termination", delete_on_termination)
+ pulumi.set(__self__, "delete_on_termination", delete_on_termination)
if dynamic_volume_size is not None:
- _setter("dynamic_volume_size", dynamic_volume_size)
+ pulumi.set(__self__, "dynamic_volume_size", dynamic_volume_size)
if encrypted is not None:
- _setter("encrypted", encrypted)
+ pulumi.set(__self__, "encrypted", encrypted)
if iops is not None:
- _setter("iops", iops)
+ pulumi.set(__self__, "iops", iops)
if kms_key_id is not None:
- _setter("kms_key_id", kms_key_id)
+ pulumi.set(__self__, "kms_key_id", kms_key_id)
if snapshot_id is not None:
- _setter("snapshot_id", snapshot_id)
+ pulumi.set(__self__, "snapshot_id", snapshot_id)
if throughput is not None:
- _setter("throughput", throughput)
+ pulumi.set(__self__, "throughput", throughput)
if volume_size is not None:
- _setter("volume_size", volume_size)
+ pulumi.set(__self__, "volume_size", volume_size)
if volume_type is not None:
- _setter("volume_type", volume_type)
+ pulumi.set(__self__, "volume_type", volume_type)
@property
@pulumi.getter(name="deleteOnTermination")
@@ -13127,34 +9819,9 @@ def __init__(__self__, *,
:param pulumi.Input[str] resource: String. Resource type to increase volume size dynamically by. (Valid values: `CPU`)
:param pulumi.Input[int] size_per_resource_unit: Int. Additional size (in GB) per resource unit. (Example: `baseSize=50`, `sizePerResourceUnit=20`, and instance with 2 CPU is launched; its total disk size will be: 90GB)
"""
- OceanLaunchSpecBlockDeviceMappingEbsDynamicVolumeSizeArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- base_size=base_size,
- resource=resource,
- size_per_resource_unit=size_per_resource_unit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- base_size: Optional[pulumi.Input[int]] = None,
- resource: Optional[pulumi.Input[str]] = None,
- size_per_resource_unit: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if base_size is None and 'baseSize' in kwargs:
- base_size = kwargs['baseSize']
- if base_size is None:
- raise TypeError("Missing 'base_size' argument")
- if resource is None:
- raise TypeError("Missing 'resource' argument")
- if size_per_resource_unit is None and 'sizePerResourceUnit' in kwargs:
- size_per_resource_unit = kwargs['sizePerResourceUnit']
- if size_per_resource_unit is None:
- raise TypeError("Missing 'size_per_resource_unit' argument")
-
- _setter("base_size", base_size)
- _setter("resource", resource)
- _setter("size_per_resource_unit", size_per_resource_unit)
+ pulumi.set(__self__, "base_size", base_size)
+ pulumi.set(__self__, "resource", resource)
+ pulumi.set(__self__, "size_per_resource_unit", size_per_resource_unit)
@property
@pulumi.getter(name="baseSize")
@@ -13200,21 +9867,8 @@ def __init__(__self__, *,
"""
:param pulumi.Input[int] initial_nodes: When set to an integer greater than 0, a corresponding amount of nodes will be launched from the created Virtual Node Group. The parameter is recommended in case the use_as_template_only (in aws.Ocean resource) is set to true during Ocean resource creation.
"""
- OceanLaunchSpecCreateOptionsArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- initial_nodes=initial_nodes,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- initial_nodes: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if initial_nodes is None and 'initialNodes' in kwargs:
- initial_nodes = kwargs['initialNodes']
-
if initial_nodes is not None:
- _setter("initial_nodes", initial_nodes)
+ pulumi.set(__self__, "initial_nodes", initial_nodes)
@property
@pulumi.getter(name="initialNodes")
@@ -13238,28 +9892,9 @@ def __init__(__self__, *,
:param pulumi.Input[bool] force_delete: When set to `true`, delete even if it is the last Virtual Node Group (also, the default Virtual Node Group must be configured with `useAsTemlateOnly = true`). Should be set at creation or update, but will be used only at deletion.
:param pulumi.Input[bool] delete_nodes: When set to "true", all instances belonging to the deleted launch specification will be drained, detached, and terminated.
"""
- OceanLaunchSpecDeleteOptionsArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- force_delete=force_delete,
- delete_nodes=delete_nodes,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- force_delete: Optional[pulumi.Input[bool]] = None,
- delete_nodes: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if force_delete is None and 'forceDelete' in kwargs:
- force_delete = kwargs['forceDelete']
- if force_delete is None:
- raise TypeError("Missing 'force_delete' argument")
- if delete_nodes is None and 'deleteNodes' in kwargs:
- delete_nodes = kwargs['deleteNodes']
-
- _setter("force_delete", force_delete)
+ pulumi.set(__self__, "force_delete", force_delete)
if delete_nodes is not None:
- _setter("delete_nodes", delete_nodes)
+ pulumi.set(__self__, "delete_nodes", delete_nodes)
@property
@pulumi.getter(name="forceDelete")
@@ -13293,21 +9928,8 @@ def __init__(__self__, *,
"""
:param pulumi.Input['OceanLaunchSpecElasticIpPoolTagSelectorArgs'] tag_selector: A key-value pair, which defines an Elastic IP from the customer pool. Can be null.
"""
- OceanLaunchSpecElasticIpPoolArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- tag_selector=tag_selector,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- tag_selector: Optional[pulumi.Input['OceanLaunchSpecElasticIpPoolTagSelectorArgs']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if tag_selector is None and 'tagSelector' in kwargs:
- tag_selector = kwargs['tagSelector']
-
if tag_selector is not None:
- _setter("tag_selector", tag_selector)
+ pulumi.set(__self__, "tag_selector", tag_selector)
@property
@pulumi.getter(name="tagSelector")
@@ -13331,28 +9953,9 @@ def __init__(__self__, *,
:param pulumi.Input[str] tag_key: Elastic IP tag key. The Virtual Node Group will consider all Elastic IPs tagged with this tag as a part of the Elastic IP pool to use.
:param pulumi.Input[str] tag_value: Elastic IP tag value. Can be null.
"""
- OceanLaunchSpecElasticIpPoolTagSelectorArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- tag_key=tag_key,
- tag_value=tag_value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- tag_key: Optional[pulumi.Input[str]] = None,
- tag_value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if tag_key is None and 'tagKey' in kwargs:
- tag_key = kwargs['tagKey']
- if tag_key is None:
- raise TypeError("Missing 'tag_key' argument")
- if tag_value is None and 'tagValue' in kwargs:
- tag_value = kwargs['tagValue']
-
- _setter("tag_key", tag_key)
+ pulumi.set(__self__, "tag_key", tag_key)
if tag_value is not None:
- _setter("tag_value", tag_value)
+ pulumi.set(__self__, "tag_value", tag_value)
@property
@pulumi.getter(name="tagKey")
@@ -13386,21 +9989,8 @@ def __init__(__self__, *,
"""
:param pulumi.Input[str] image_id: Identifier of the image in AWS. Valid values: any string which is not empty or null.
"""
- OceanLaunchSpecImageArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- image_id=image_id,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- image_id: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if image_id is None and 'imageId' in kwargs:
- image_id = kwargs['imageId']
-
if image_id is not None:
- _setter("image_id", image_id)
+ pulumi.set(__self__, "image_id", image_id)
@property
@pulumi.getter(name="imageId")
@@ -13424,28 +10014,9 @@ def __init__(__self__, *,
:param pulumi.Input[str] http_tokens: Determines if a signed token is required or not. Valid values: `optional` or `required`.
:param pulumi.Input[int] http_put_response_hop_limit: An integer from 1 through 64. The desired HTTP PUT response hop limit for instance metadata requests. The larger the number, the further the instance metadata requests can travel.
"""
- OceanLaunchSpecInstanceMetadataOptionsArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- http_tokens=http_tokens,
- http_put_response_hop_limit=http_put_response_hop_limit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- http_tokens: Optional[pulumi.Input[str]] = None,
- http_put_response_hop_limit: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if http_tokens is None and 'httpTokens' in kwargs:
- http_tokens = kwargs['httpTokens']
- if http_tokens is None:
- raise TypeError("Missing 'http_tokens' argument")
- if http_put_response_hop_limit is None and 'httpPutResponseHopLimit' in kwargs:
- http_put_response_hop_limit = kwargs['httpPutResponseHopLimit']
-
- _setter("http_tokens", http_tokens)
+ pulumi.set(__self__, "http_tokens", http_tokens)
if http_put_response_hop_limit is not None:
- _setter("http_put_response_hop_limit", http_put_response_hop_limit)
+ pulumi.set(__self__, "http_put_response_hop_limit", http_put_response_hop_limit)
@property
@pulumi.getter(name="httpTokens")
@@ -13516,119 +10087,42 @@ def __init__(__self__, *,
"""
- OceanLaunchSpecInstanceTypesFiltersArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- categories=categories,
- disk_types=disk_types,
- exclude_families=exclude_families,
- exclude_metal=exclude_metal,
- hypervisors=hypervisors,
- include_families=include_families,
- is_ena_supported=is_ena_supported,
- max_gpu=max_gpu,
- max_memory_gib=max_memory_gib,
- max_network_performance=max_network_performance,
- max_vcpu=max_vcpu,
- min_enis=min_enis,
- min_gpu=min_gpu,
- min_memory_gib=min_memory_gib,
- min_network_performance=min_network_performance,
- min_vcpu=min_vcpu,
- root_device_types=root_device_types,
- virtualization_types=virtualization_types,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- categories: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- disk_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- exclude_families: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- exclude_metal: Optional[pulumi.Input[bool]] = None,
- hypervisors: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- include_families: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- is_ena_supported: Optional[pulumi.Input[str]] = None,
- max_gpu: Optional[pulumi.Input[int]] = None,
- max_memory_gib: Optional[pulumi.Input[float]] = None,
- max_network_performance: Optional[pulumi.Input[int]] = None,
- max_vcpu: Optional[pulumi.Input[int]] = None,
- min_enis: Optional[pulumi.Input[int]] = None,
- min_gpu: Optional[pulumi.Input[int]] = None,
- min_memory_gib: Optional[pulumi.Input[float]] = None,
- min_network_performance: Optional[pulumi.Input[int]] = None,
- min_vcpu: Optional[pulumi.Input[int]] = None,
- root_device_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- virtualization_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if disk_types is None and 'diskTypes' in kwargs:
- disk_types = kwargs['diskTypes']
- if exclude_families is None and 'excludeFamilies' in kwargs:
- exclude_families = kwargs['excludeFamilies']
- if exclude_metal is None and 'excludeMetal' in kwargs:
- exclude_metal = kwargs['excludeMetal']
- if include_families is None and 'includeFamilies' in kwargs:
- include_families = kwargs['includeFamilies']
- if is_ena_supported is None and 'isEnaSupported' in kwargs:
- is_ena_supported = kwargs['isEnaSupported']
- if max_gpu is None and 'maxGpu' in kwargs:
- max_gpu = kwargs['maxGpu']
- if max_memory_gib is None and 'maxMemoryGib' in kwargs:
- max_memory_gib = kwargs['maxMemoryGib']
- if max_network_performance is None and 'maxNetworkPerformance' in kwargs:
- max_network_performance = kwargs['maxNetworkPerformance']
- if max_vcpu is None and 'maxVcpu' in kwargs:
- max_vcpu = kwargs['maxVcpu']
- if min_enis is None and 'minEnis' in kwargs:
- min_enis = kwargs['minEnis']
- if min_gpu is None and 'minGpu' in kwargs:
- min_gpu = kwargs['minGpu']
- if min_memory_gib is None and 'minMemoryGib' in kwargs:
- min_memory_gib = kwargs['minMemoryGib']
- if min_network_performance is None and 'minNetworkPerformance' in kwargs:
- min_network_performance = kwargs['minNetworkPerformance']
- if min_vcpu is None and 'minVcpu' in kwargs:
- min_vcpu = kwargs['minVcpu']
- if root_device_types is None and 'rootDeviceTypes' in kwargs:
- root_device_types = kwargs['rootDeviceTypes']
- if virtualization_types is None and 'virtualizationTypes' in kwargs:
- virtualization_types = kwargs['virtualizationTypes']
-
if categories is not None:
- _setter("categories", categories)
+ pulumi.set(__self__, "categories", categories)
if disk_types is not None:
- _setter("disk_types", disk_types)
+ pulumi.set(__self__, "disk_types", disk_types)
if exclude_families is not None:
- _setter("exclude_families", exclude_families)
+ pulumi.set(__self__, "exclude_families", exclude_families)
if exclude_metal is not None:
- _setter("exclude_metal", exclude_metal)
+ pulumi.set(__self__, "exclude_metal", exclude_metal)
if hypervisors is not None:
- _setter("hypervisors", hypervisors)
+ pulumi.set(__self__, "hypervisors", hypervisors)
if include_families is not None:
- _setter("include_families", include_families)
+ pulumi.set(__self__, "include_families", include_families)
if is_ena_supported is not None:
- _setter("is_ena_supported", is_ena_supported)
+ pulumi.set(__self__, "is_ena_supported", is_ena_supported)
if max_gpu is not None:
- _setter("max_gpu", max_gpu)
+ pulumi.set(__self__, "max_gpu", max_gpu)
if max_memory_gib is not None:
- _setter("max_memory_gib", max_memory_gib)
+ pulumi.set(__self__, "max_memory_gib", max_memory_gib)
if max_network_performance is not None:
- _setter("max_network_performance", max_network_performance)
+ pulumi.set(__self__, "max_network_performance", max_network_performance)
if max_vcpu is not None:
- _setter("max_vcpu", max_vcpu)
+ pulumi.set(__self__, "max_vcpu", max_vcpu)
if min_enis is not None:
- _setter("min_enis", min_enis)
+ pulumi.set(__self__, "min_enis", min_enis)
if min_gpu is not None:
- _setter("min_gpu", min_gpu)
+ pulumi.set(__self__, "min_gpu", min_gpu)
if min_memory_gib is not None:
- _setter("min_memory_gib", min_memory_gib)
+ pulumi.set(__self__, "min_memory_gib", min_memory_gib)
if min_network_performance is not None:
- _setter("min_network_performance", min_network_performance)
+ pulumi.set(__self__, "min_network_performance", min_network_performance)
if min_vcpu is not None:
- _setter("min_vcpu", min_vcpu)
+ pulumi.set(__self__, "min_vcpu", min_vcpu)
if root_device_types is not None:
- _setter("root_device_types", root_device_types)
+ pulumi.set(__self__, "root_device_types", root_device_types)
if virtualization_types is not None:
- _setter("virtualization_types", virtualization_types)
+ pulumi.set(__self__, "virtualization_types", virtualization_types)
@property
@pulumi.getter
@@ -13859,25 +10353,8 @@ def __init__(__self__, *,
:param pulumi.Input[str] key: The taint key.
:param pulumi.Input[str] value: The taint value.
"""
- OceanLaunchSpecLabelArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -13913,27 +10390,10 @@ def __init__(__self__, *,
:param pulumi.Input[int] max_instance_count: Set a maximum number of instances per Virtual Node Group. Can be null. If set, value must be greater than or equal to 0.
:param pulumi.Input[int] min_instance_count: Set a minimum number of instances per Virtual Node Group. Can be null. If set, value must be greater than or equal to 0.
"""
- OceanLaunchSpecResourceLimitArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- max_instance_count=max_instance_count,
- min_instance_count=min_instance_count,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- max_instance_count: Optional[pulumi.Input[int]] = None,
- min_instance_count: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if max_instance_count is None and 'maxInstanceCount' in kwargs:
- max_instance_count = kwargs['maxInstanceCount']
- if min_instance_count is None and 'minInstanceCount' in kwargs:
- min_instance_count = kwargs['minInstanceCount']
-
if max_instance_count is not None:
- _setter("max_instance_count", max_instance_count)
+ pulumi.set(__self__, "max_instance_count", max_instance_count)
if min_instance_count is not None:
- _setter("min_instance_count", min_instance_count)
+ pulumi.set(__self__, "min_instance_count", min_instance_count)
@property
@pulumi.getter(name="maxInstanceCount")
@@ -13969,28 +10429,9 @@ def __init__(__self__, *,
:param pulumi.Input[Sequence[pulumi.Input[str]]] time_windows: The times that the shutdown hours will apply.
:param pulumi.Input[bool] is_enabled: Flag to enable or disable the shutdown hours mechanism. When False, the mechanism is deactivated, and the virtual node group remains in its current state.
"""
- OceanLaunchSpecSchedulingShutdownHoursArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- time_windows=time_windows,
- is_enabled=is_enabled,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- time_windows: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- is_enabled: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if time_windows is None and 'timeWindows' in kwargs:
- time_windows = kwargs['timeWindows']
- if time_windows is None:
- raise TypeError("Missing 'time_windows' argument")
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
-
- _setter("time_windows", time_windows)
+ pulumi.set(__self__, "time_windows", time_windows)
if is_enabled is not None:
- _setter("is_enabled", is_enabled)
+ pulumi.set(__self__, "is_enabled", is_enabled)
@property
@pulumi.getter(name="timeWindows")
@@ -14030,42 +10471,11 @@ def __init__(__self__, *,
:param pulumi.Input[str] task_type: The activity that you are scheduling. Valid values: "manualHeadroomUpdate".
:param pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecSchedulingTaskTaskHeadroomArgs']]] task_headrooms: The config of this scheduled task. Depends on the value of taskType.
"""
- OceanLaunchSpecSchedulingTaskArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cron_expression=cron_expression,
- is_enabled=is_enabled,
- task_type=task_type,
- task_headrooms=task_headrooms,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cron_expression: Optional[pulumi.Input[str]] = None,
- is_enabled: Optional[pulumi.Input[bool]] = None,
- task_type: Optional[pulumi.Input[str]] = None,
- task_headrooms: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecSchedulingTaskTaskHeadroomArgs']]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cron_expression is None and 'cronExpression' in kwargs:
- cron_expression = kwargs['cronExpression']
- if cron_expression is None:
- raise TypeError("Missing 'cron_expression' argument")
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
- if is_enabled is None:
- raise TypeError("Missing 'is_enabled' argument")
- if task_type is None and 'taskType' in kwargs:
- task_type = kwargs['taskType']
- if task_type is None:
- raise TypeError("Missing 'task_type' argument")
- if task_headrooms is None and 'taskHeadrooms' in kwargs:
- task_headrooms = kwargs['taskHeadrooms']
-
- _setter("cron_expression", cron_expression)
- _setter("is_enabled", is_enabled)
- _setter("task_type", task_type)
+ pulumi.set(__self__, "cron_expression", cron_expression)
+ pulumi.set(__self__, "is_enabled", is_enabled)
+ pulumi.set(__self__, "task_type", task_type)
if task_headrooms is not None:
- _setter("task_headrooms", task_headrooms)
+ pulumi.set(__self__, "task_headrooms", task_headrooms)
@property
@pulumi.getter(name="cronExpression")
@@ -14129,40 +10539,13 @@ def __init__(__self__, *,
:param pulumi.Input[int] gpu_per_unit: Optionally configure the number of GPUS to allocate for each headroom unit.
:param pulumi.Input[int] memory_per_unit: Optionally configure the amount of memory (MiB) to allocate for each headroom unit.
"""
- OceanLaunchSpecSchedulingTaskTaskHeadroomArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- num_of_units=num_of_units,
- cpu_per_unit=cpu_per_unit,
- gpu_per_unit=gpu_per_unit,
- memory_per_unit=memory_per_unit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- num_of_units: Optional[pulumi.Input[int]] = None,
- cpu_per_unit: Optional[pulumi.Input[int]] = None,
- gpu_per_unit: Optional[pulumi.Input[int]] = None,
- memory_per_unit: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if num_of_units is None and 'numOfUnits' in kwargs:
- num_of_units = kwargs['numOfUnits']
- if num_of_units is None:
- raise TypeError("Missing 'num_of_units' argument")
- if cpu_per_unit is None and 'cpuPerUnit' in kwargs:
- cpu_per_unit = kwargs['cpuPerUnit']
- if gpu_per_unit is None and 'gpuPerUnit' in kwargs:
- gpu_per_unit = kwargs['gpuPerUnit']
- if memory_per_unit is None and 'memoryPerUnit' in kwargs:
- memory_per_unit = kwargs['memoryPerUnit']
-
- _setter("num_of_units", num_of_units)
+ pulumi.set(__self__, "num_of_units", num_of_units)
if cpu_per_unit is not None:
- _setter("cpu_per_unit", cpu_per_unit)
+ pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
if gpu_per_unit is not None:
- _setter("gpu_per_unit", gpu_per_unit)
+ pulumi.set(__self__, "gpu_per_unit", gpu_per_unit)
if memory_per_unit is not None:
- _setter("memory_per_unit", memory_per_unit)
+ pulumi.set(__self__, "memory_per_unit", memory_per_unit)
@property
@pulumi.getter(name="numOfUnits")
@@ -14220,21 +10603,8 @@ def __init__(__self__, *,
"""
:param pulumi.Input[int] spot_percentage: The desired percentage of the Spot instances out of all running instances for this VNG. Only available when the field is not set in the cluster directly (cluster.strategy.spotPercentage).
"""
- OceanLaunchSpecStrategyArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- spot_percentage=spot_percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- spot_percentage: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if spot_percentage is None and 'spotPercentage' in kwargs:
- spot_percentage = kwargs['spotPercentage']
-
if spot_percentage is not None:
- _setter("spot_percentage", spot_percentage)
+ pulumi.set(__self__, "spot_percentage", spot_percentage)
@property
@pulumi.getter(name="spotPercentage")
@@ -14258,25 +10628,8 @@ def __init__(__self__, *,
:param pulumi.Input[str] key: The taint key.
:param pulumi.Input[str] value: The taint value.
"""
- OceanLaunchSpecTagArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -14314,30 +10667,9 @@ def __init__(__self__, *,
:param pulumi.Input[str] key: The taint key.
:param pulumi.Input[str] value: The taint value.
"""
- OceanLaunchSpecTaintArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- effect=effect,
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- effect: Optional[pulumi.Input[str]] = None,
- key: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if effect is None:
- raise TypeError("Missing 'effect' argument")
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("effect", effect)
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "effect", effect)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -14381,28 +10713,9 @@ class OceanLaunchSpecUpdatePolicyArgs:
def __init__(__self__, *,
should_roll: pulumi.Input[bool],
roll_config: Optional[pulumi.Input['OceanLaunchSpecUpdatePolicyRollConfigArgs']] = None):
- OceanLaunchSpecUpdatePolicyArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- should_roll=should_roll,
- roll_config=roll_config,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- should_roll: Optional[pulumi.Input[bool]] = None,
- roll_config: Optional[pulumi.Input['OceanLaunchSpecUpdatePolicyRollConfigArgs']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if should_roll is None and 'shouldRoll' in kwargs:
- should_roll = kwargs['shouldRoll']
- if should_roll is None:
- raise TypeError("Missing 'should_roll' argument")
- if roll_config is None and 'rollConfig' in kwargs:
- roll_config = kwargs['rollConfig']
-
- _setter("should_roll", should_roll)
+ pulumi.set(__self__, "should_roll", should_roll)
if roll_config is not None:
- _setter("roll_config", roll_config)
+ pulumi.set(__self__, "roll_config", roll_config)
@property
@pulumi.getter(name="shouldRoll")
@@ -14427,22 +10740,7 @@ def roll_config(self, value: Optional[pulumi.Input['OceanLaunchSpecUpdatePolicyR
class OceanLaunchSpecUpdatePolicyRollConfigArgs:
def __init__(__self__, *,
batch_size_percentage: pulumi.Input[int]):
- OceanLaunchSpecUpdatePolicyRollConfigArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- batch_size_percentage=batch_size_percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- batch_size_percentage: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if batch_size_percentage is None and 'batchSizePercentage' in kwargs:
- batch_size_percentage = kwargs['batchSizePercentage']
- if batch_size_percentage is None:
- raise TypeError("Missing 'batch_size_percentage' argument")
-
- _setter("batch_size_percentage", batch_size_percentage)
+ pulumi.set(__self__, "batch_size_percentage", batch_size_percentage)
@property
@pulumi.getter(name="batchSizePercentage")
@@ -14465,27 +10763,12 @@ def __init__(__self__, *,
:param pulumi.Input[str] name: Required if type is set to `CLASSIC`
:param pulumi.Input[str] type: Can be set to `CLASSIC` or `TARGET_GROUP`
"""
- OceanLoadBalancerArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- arn=arn,
- name=name,
- type=type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- arn: Optional[pulumi.Input[str]] = None,
- name: Optional[pulumi.Input[str]] = None,
- type: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if arn is not None:
- _setter("arn", arn)
+ pulumi.set(__self__, "arn", arn)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if type is not None:
- _setter("type", type)
+ pulumi.set(__self__, "type", type)
@property
@pulumi.getter
@@ -14531,19 +10814,8 @@ def __init__(__self__, *,
"""
:param pulumi.Input['OceanLoggingExportArgs'] export: Logging Export configuration.
"""
- OceanLoggingArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- export=export,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- export: Optional[pulumi.Input['OceanLoggingExportArgs']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if export is not None:
- _setter("export", export)
+ pulumi.set(__self__, "export", export)
@property
@pulumi.getter
@@ -14565,19 +10837,8 @@ def __init__(__self__, *,
"""
:param pulumi.Input[Sequence[pulumi.Input['OceanLoggingExportS3Args']]] s3s: Exports your cluster's logs to the S3 bucket and subdir configured on the S3 data integration given.
"""
- OceanLoggingExportArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- s3s=s3s,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- s3s: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLoggingExportS3Args']]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if s3s is not None:
- _setter("s3s", s3s)
+ pulumi.set(__self__, "s3s", s3s)
@property
@pulumi.getter
@@ -14599,20 +10860,7 @@ def __init__(__self__, *,
"""
:param pulumi.Input[str] id: The identifier of The S3 data integration to export the logs to.
"""
- OceanLoggingExportS3Args._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- id=id,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- id: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if id is None:
- raise TypeError("Missing 'id' argument")
-
- _setter("id", id)
+ pulumi.set(__self__, "id", id)
@property
@pulumi.getter
@@ -14634,21 +10882,8 @@ def __init__(__self__, *,
"""
:param pulumi.Input[bool] should_tag_volumes: Specify if Volume resources will be tagged with Virtual Node Group tags or Ocean tags.
"""
- OceanResourceTagSpecificationArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- should_tag_volumes=should_tag_volumes,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- should_tag_volumes: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if should_tag_volumes is None and 'shouldTagVolumes' in kwargs:
- should_tag_volumes = kwargs['shouldTagVolumes']
-
if should_tag_volumes is not None:
- _setter("should_tag_volumes", should_tag_volumes)
+ pulumi.set(__self__, "should_tag_volumes", should_tag_volumes)
@property
@pulumi.getter(name="shouldTagVolumes")
@@ -14668,25 +10903,10 @@ class OceanScheduledTaskArgs:
def __init__(__self__, *,
shutdown_hours: Optional[pulumi.Input['OceanScheduledTaskShutdownHoursArgs']] = None,
tasks: Optional[pulumi.Input[Sequence[pulumi.Input['OceanScheduledTaskTaskArgs']]]] = None):
- OceanScheduledTaskArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- shutdown_hours=shutdown_hours,
- tasks=tasks,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- shutdown_hours: Optional[pulumi.Input['OceanScheduledTaskShutdownHoursArgs']] = None,
- tasks: Optional[pulumi.Input[Sequence[pulumi.Input['OceanScheduledTaskTaskArgs']]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if shutdown_hours is None and 'shutdownHours' in kwargs:
- shutdown_hours = kwargs['shutdownHours']
-
if shutdown_hours is not None:
- _setter("shutdown_hours", shutdown_hours)
+ pulumi.set(__self__, "shutdown_hours", shutdown_hours)
if tasks is not None:
- _setter("tasks", tasks)
+ pulumi.set(__self__, "tasks", tasks)
@property
@pulumi.getter(name="shutdownHours")
@@ -14712,28 +10932,9 @@ class OceanScheduledTaskShutdownHoursArgs:
def __init__(__self__, *,
time_windows: pulumi.Input[Sequence[pulumi.Input[str]]],
is_enabled: Optional[pulumi.Input[bool]] = None):
- OceanScheduledTaskShutdownHoursArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- time_windows=time_windows,
- is_enabled=is_enabled,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- time_windows: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- is_enabled: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if time_windows is None and 'timeWindows' in kwargs:
- time_windows = kwargs['timeWindows']
- if time_windows is None:
- raise TypeError("Missing 'time_windows' argument")
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
-
- _setter("time_windows", time_windows)
+ pulumi.set(__self__, "time_windows", time_windows)
if is_enabled is not None:
- _setter("is_enabled", is_enabled)
+ pulumi.set(__self__, "is_enabled", is_enabled)
@property
@pulumi.getter(name="timeWindows")
@@ -14760,36 +10961,9 @@ def __init__(__self__, *,
cron_expression: pulumi.Input[str],
is_enabled: pulumi.Input[bool],
task_type: pulumi.Input[str]):
- OceanScheduledTaskTaskArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cron_expression=cron_expression,
- is_enabled=is_enabled,
- task_type=task_type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cron_expression: Optional[pulumi.Input[str]] = None,
- is_enabled: Optional[pulumi.Input[bool]] = None,
- task_type: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cron_expression is None and 'cronExpression' in kwargs:
- cron_expression = kwargs['cronExpression']
- if cron_expression is None:
- raise TypeError("Missing 'cron_expression' argument")
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
- if is_enabled is None:
- raise TypeError("Missing 'is_enabled' argument")
- if task_type is None and 'taskType' in kwargs:
- task_type = kwargs['taskType']
- if task_type is None:
- raise TypeError("Missing 'task_type' argument")
-
- _setter("cron_expression", cron_expression)
- _setter("is_enabled", is_enabled)
- _setter("task_type", task_type)
+ pulumi.set(__self__, "cron_expression", cron_expression)
+ pulumi.set(__self__, "is_enabled", is_enabled)
+ pulumi.set(__self__, "task_type", task_type)
@property
@pulumi.getter(name="cronExpression")
@@ -14828,25 +11002,8 @@ def __init__(__self__, *,
:param pulumi.Input[str] key: The tag key.
:param pulumi.Input[str] value: The tag value.
"""
- OceanTagArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -14880,40 +11037,13 @@ def __init__(__self__, *,
auto_apply_tags: Optional[pulumi.Input[bool]] = None,
conditioned_roll: Optional[pulumi.Input[bool]] = None,
roll_config: Optional[pulumi.Input['OceanUpdatePolicyRollConfigArgs']] = None):
- OceanUpdatePolicyArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- should_roll=should_roll,
- auto_apply_tags=auto_apply_tags,
- conditioned_roll=conditioned_roll,
- roll_config=roll_config,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- should_roll: Optional[pulumi.Input[bool]] = None,
- auto_apply_tags: Optional[pulumi.Input[bool]] = None,
- conditioned_roll: Optional[pulumi.Input[bool]] = None,
- roll_config: Optional[pulumi.Input['OceanUpdatePolicyRollConfigArgs']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if should_roll is None and 'shouldRoll' in kwargs:
- should_roll = kwargs['shouldRoll']
- if should_roll is None:
- raise TypeError("Missing 'should_roll' argument")
- if auto_apply_tags is None and 'autoApplyTags' in kwargs:
- auto_apply_tags = kwargs['autoApplyTags']
- if conditioned_roll is None and 'conditionedRoll' in kwargs:
- conditioned_roll = kwargs['conditionedRoll']
- if roll_config is None and 'rollConfig' in kwargs:
- roll_config = kwargs['rollConfig']
-
- _setter("should_roll", should_roll)
+ pulumi.set(__self__, "should_roll", should_roll)
if auto_apply_tags is not None:
- _setter("auto_apply_tags", auto_apply_tags)
+ pulumi.set(__self__, "auto_apply_tags", auto_apply_tags)
if conditioned_roll is not None:
- _setter("conditioned_roll", conditioned_roll)
+ pulumi.set(__self__, "conditioned_roll", conditioned_roll)
if roll_config is not None:
- _setter("roll_config", roll_config)
+ pulumi.set(__self__, "roll_config", roll_config)
@property
@pulumi.getter(name="shouldRoll")
@@ -14959,40 +11089,13 @@ def __init__(__self__, *,
batch_min_healthy_percentage: Optional[pulumi.Input[int]] = None,
launch_spec_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
respect_pdb: Optional[pulumi.Input[bool]] = None):
- OceanUpdatePolicyRollConfigArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- batch_size_percentage=batch_size_percentage,
- batch_min_healthy_percentage=batch_min_healthy_percentage,
- launch_spec_ids=launch_spec_ids,
- respect_pdb=respect_pdb,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- batch_size_percentage: Optional[pulumi.Input[int]] = None,
- batch_min_healthy_percentage: Optional[pulumi.Input[int]] = None,
- launch_spec_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- respect_pdb: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if batch_size_percentage is None and 'batchSizePercentage' in kwargs:
- batch_size_percentage = kwargs['batchSizePercentage']
- if batch_size_percentage is None:
- raise TypeError("Missing 'batch_size_percentage' argument")
- if batch_min_healthy_percentage is None and 'batchMinHealthyPercentage' in kwargs:
- batch_min_healthy_percentage = kwargs['batchMinHealthyPercentage']
- if launch_spec_ids is None and 'launchSpecIds' in kwargs:
- launch_spec_ids = kwargs['launchSpecIds']
- if respect_pdb is None and 'respectPdb' in kwargs:
- respect_pdb = kwargs['respectPdb']
-
- _setter("batch_size_percentage", batch_size_percentage)
+ pulumi.set(__self__, "batch_size_percentage", batch_size_percentage)
if batch_min_healthy_percentage is not None:
- _setter("batch_min_healthy_percentage", batch_min_healthy_percentage)
+ pulumi.set(__self__, "batch_min_healthy_percentage", batch_min_healthy_percentage)
if launch_spec_ids is not None:
- _setter("launch_spec_ids", launch_spec_ids)
+ pulumi.set(__self__, "launch_spec_ids", launch_spec_ids)
if respect_pdb is not None:
- _setter("respect_pdb", respect_pdb)
+ pulumi.set(__self__, "respect_pdb", respect_pdb)
@property
@pulumi.getter(name="batchSizePercentage")
@@ -15038,20 +11141,7 @@ def __init__(__self__, *,
"""
:param pulumi.Input[str] name: The name of process to suspend. Valid values: `"AUTO_HEALING" , "OUT_OF_STRATEGY", "PREVENTIVE_REPLACEMENT", "REVERT_PREFERRED", or "SCHEDULING"`.
"""
- SuspensionSuspensionArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
-
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
@property
@pulumi.getter
diff --git a/sdk/python/pulumi_spotinst/aws/account.py b/sdk/python/pulumi_spotinst/aws/account.py
index 10d4d86b..66b832ec 100644
--- a/sdk/python/pulumi_spotinst/aws/account.py
+++ b/sdk/python/pulumi_spotinst/aws/account.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
__all__ = ['AccountArgs', 'Account']
@@ -19,19 +19,8 @@ def __init__(__self__, *,
The set of arguments for constructing a Account resource.
:param pulumi.Input[str] name: Provide a name for your account. The account name must contain at least one character that is a-z or A-Z.
"""
- AccountArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
@property
@pulumi.getter
@@ -54,19 +43,8 @@ def __init__(__self__, *,
Input properties used for looking up and filtering Account resources.
:param pulumi.Input[str] name: Provide a name for your account. The account name must contain at least one character that is a-z or A-Z.
"""
- _AccountState._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
@property
@pulumi.getter
@@ -134,10 +112,6 @@ def __init__(__self__, resource_name: str, *args, **kwargs):
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
- kwargs = kwargs or {}
- def _setter(key, value):
- kwargs[key] = value
- AccountArgs._configure(_setter, **kwargs)
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
diff --git a/sdk/python/pulumi_spotinst/aws/beanstalk.py b/sdk/python/pulumi_spotinst/aws/beanstalk.py
index 1dce333d..d2147aef 100644
--- a/sdk/python/pulumi_spotinst/aws/beanstalk.py
+++ b/sdk/python/pulumi_spotinst/aws/beanstalk.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs
from ._inputs import *
@@ -44,91 +44,26 @@ def __init__(__self__, *,
:param pulumi.Input['BeanstalkManagedActionsArgs'] managed_actions: Managed Actions parameters
:param pulumi.Input[str] name: The group name.
"""
- BeanstalkArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- desired_capacity=desired_capacity,
- instance_types_spots=instance_types_spots,
- max_size=max_size,
- min_size=min_size,
- product=product,
- region=region,
- beanstalk_environment_id=beanstalk_environment_id,
- beanstalk_environment_name=beanstalk_environment_name,
- deployment_preferences=deployment_preferences,
- maintenance=maintenance,
- managed_actions=managed_actions,
- name=name,
- scheduled_tasks=scheduled_tasks,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- desired_capacity: Optional[pulumi.Input[int]] = None,
- instance_types_spots: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- max_size: Optional[pulumi.Input[int]] = None,
- min_size: Optional[pulumi.Input[int]] = None,
- product: Optional[pulumi.Input[str]] = None,
- region: Optional[pulumi.Input[str]] = None,
- beanstalk_environment_id: Optional[pulumi.Input[str]] = None,
- beanstalk_environment_name: Optional[pulumi.Input[str]] = None,
- deployment_preferences: Optional[pulumi.Input['BeanstalkDeploymentPreferencesArgs']] = None,
- maintenance: Optional[pulumi.Input[str]] = None,
- managed_actions: Optional[pulumi.Input['BeanstalkManagedActionsArgs']] = None,
- name: Optional[pulumi.Input[str]] = None,
- scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['BeanstalkScheduledTaskArgs']]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if desired_capacity is None and 'desiredCapacity' in kwargs:
- desired_capacity = kwargs['desiredCapacity']
- if desired_capacity is None:
- raise TypeError("Missing 'desired_capacity' argument")
- if instance_types_spots is None and 'instanceTypesSpots' in kwargs:
- instance_types_spots = kwargs['instanceTypesSpots']
- if instance_types_spots is None:
- raise TypeError("Missing 'instance_types_spots' argument")
- if max_size is None and 'maxSize' in kwargs:
- max_size = kwargs['maxSize']
- if max_size is None:
- raise TypeError("Missing 'max_size' argument")
- if min_size is None and 'minSize' in kwargs:
- min_size = kwargs['minSize']
- if min_size is None:
- raise TypeError("Missing 'min_size' argument")
- if product is None:
- raise TypeError("Missing 'product' argument")
- if region is None:
- raise TypeError("Missing 'region' argument")
- if beanstalk_environment_id is None and 'beanstalkEnvironmentId' in kwargs:
- beanstalk_environment_id = kwargs['beanstalkEnvironmentId']
- if beanstalk_environment_name is None and 'beanstalkEnvironmentName' in kwargs:
- beanstalk_environment_name = kwargs['beanstalkEnvironmentName']
- if deployment_preferences is None and 'deploymentPreferences' in kwargs:
- deployment_preferences = kwargs['deploymentPreferences']
- if managed_actions is None and 'managedActions' in kwargs:
- managed_actions = kwargs['managedActions']
- if scheduled_tasks is None and 'scheduledTasks' in kwargs:
- scheduled_tasks = kwargs['scheduledTasks']
-
- _setter("desired_capacity", desired_capacity)
- _setter("instance_types_spots", instance_types_spots)
- _setter("max_size", max_size)
- _setter("min_size", min_size)
- _setter("product", product)
- _setter("region", region)
+ pulumi.set(__self__, "desired_capacity", desired_capacity)
+ pulumi.set(__self__, "instance_types_spots", instance_types_spots)
+ pulumi.set(__self__, "max_size", max_size)
+ pulumi.set(__self__, "min_size", min_size)
+ pulumi.set(__self__, "product", product)
+ pulumi.set(__self__, "region", region)
if beanstalk_environment_id is not None:
- _setter("beanstalk_environment_id", beanstalk_environment_id)
+ pulumi.set(__self__, "beanstalk_environment_id", beanstalk_environment_id)
if beanstalk_environment_name is not None:
- _setter("beanstalk_environment_name", beanstalk_environment_name)
+ pulumi.set(__self__, "beanstalk_environment_name", beanstalk_environment_name)
if deployment_preferences is not None:
- _setter("deployment_preferences", deployment_preferences)
+ pulumi.set(__self__, "deployment_preferences", deployment_preferences)
if maintenance is not None:
- _setter("maintenance", maintenance)
+ pulumi.set(__self__, "maintenance", maintenance)
if managed_actions is not None:
- _setter("managed_actions", managed_actions)
+ pulumi.set(__self__, "managed_actions", managed_actions)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if scheduled_tasks is not None:
- _setter("scheduled_tasks", scheduled_tasks)
+ pulumi.set(__self__, "scheduled_tasks", scheduled_tasks)
@property
@pulumi.getter(name="desiredCapacity")
@@ -313,85 +248,32 @@ def __init__(__self__, *,
For EC2 Classic instances: `"Linux/UNIX (Amazon VPC)"`, `"SUSE Linux (Amazon VPC)"`, `"Windows (Amazon VPC)"`.
:param pulumi.Input[str] region: The AWS region your group will be created in. Cannot be changed after the group has been created.
"""
- _BeanstalkState._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- beanstalk_environment_id=beanstalk_environment_id,
- beanstalk_environment_name=beanstalk_environment_name,
- deployment_preferences=deployment_preferences,
- desired_capacity=desired_capacity,
- instance_types_spots=instance_types_spots,
- maintenance=maintenance,
- managed_actions=managed_actions,
- max_size=max_size,
- min_size=min_size,
- name=name,
- product=product,
- region=region,
- scheduled_tasks=scheduled_tasks,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- beanstalk_environment_id: Optional[pulumi.Input[str]] = None,
- beanstalk_environment_name: Optional[pulumi.Input[str]] = None,
- deployment_preferences: Optional[pulumi.Input['BeanstalkDeploymentPreferencesArgs']] = None,
- desired_capacity: Optional[pulumi.Input[int]] = None,
- instance_types_spots: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- maintenance: Optional[pulumi.Input[str]] = None,
- managed_actions: Optional[pulumi.Input['BeanstalkManagedActionsArgs']] = None,
- max_size: Optional[pulumi.Input[int]] = None,
- min_size: Optional[pulumi.Input[int]] = None,
- name: Optional[pulumi.Input[str]] = None,
- product: Optional[pulumi.Input[str]] = None,
- region: Optional[pulumi.Input[str]] = None,
- scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['BeanstalkScheduledTaskArgs']]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if beanstalk_environment_id is None and 'beanstalkEnvironmentId' in kwargs:
- beanstalk_environment_id = kwargs['beanstalkEnvironmentId']
- if beanstalk_environment_name is None and 'beanstalkEnvironmentName' in kwargs:
- beanstalk_environment_name = kwargs['beanstalkEnvironmentName']
- if deployment_preferences is None and 'deploymentPreferences' in kwargs:
- deployment_preferences = kwargs['deploymentPreferences']
- if desired_capacity is None and 'desiredCapacity' in kwargs:
- desired_capacity = kwargs['desiredCapacity']
- if instance_types_spots is None and 'instanceTypesSpots' in kwargs:
- instance_types_spots = kwargs['instanceTypesSpots']
- if managed_actions is None and 'managedActions' in kwargs:
- managed_actions = kwargs['managedActions']
- if max_size is None and 'maxSize' in kwargs:
- max_size = kwargs['maxSize']
- if min_size is None and 'minSize' in kwargs:
- min_size = kwargs['minSize']
- if scheduled_tasks is None and 'scheduledTasks' in kwargs:
- scheduled_tasks = kwargs['scheduledTasks']
-
if beanstalk_environment_id is not None:
- _setter("beanstalk_environment_id", beanstalk_environment_id)
+ pulumi.set(__self__, "beanstalk_environment_id", beanstalk_environment_id)
if beanstalk_environment_name is not None:
- _setter("beanstalk_environment_name", beanstalk_environment_name)
+ pulumi.set(__self__, "beanstalk_environment_name", beanstalk_environment_name)
if deployment_preferences is not None:
- _setter("deployment_preferences", deployment_preferences)
+ pulumi.set(__self__, "deployment_preferences", deployment_preferences)
if desired_capacity is not None:
- _setter("desired_capacity", desired_capacity)
+ pulumi.set(__self__, "desired_capacity", desired_capacity)
if instance_types_spots is not None:
- _setter("instance_types_spots", instance_types_spots)
+ pulumi.set(__self__, "instance_types_spots", instance_types_spots)
if maintenance is not None:
- _setter("maintenance", maintenance)
+ pulumi.set(__self__, "maintenance", maintenance)
if managed_actions is not None:
- _setter("managed_actions", managed_actions)
+ pulumi.set(__self__, "managed_actions", managed_actions)
if max_size is not None:
- _setter("max_size", max_size)
+ pulumi.set(__self__, "max_size", max_size)
if min_size is not None:
- _setter("min_size", min_size)
+ pulumi.set(__self__, "min_size", min_size)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if product is not None:
- _setter("product", product)
+ pulumi.set(__self__, "product", product)
if region is not None:
- _setter("region", region)
+ pulumi.set(__self__, "region", region)
if scheduled_tasks is not None:
- _setter("scheduled_tasks", scheduled_tasks)
+ pulumi.set(__self__, "scheduled_tasks", scheduled_tasks)
@property
@pulumi.getter(name="beanstalkEnvironmentId")
@@ -675,10 +557,6 @@ def __init__(__self__, resource_name: str, *args, **kwargs):
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
- kwargs = kwargs or {}
- def _setter(key, value):
- kwargs[key] = value
- BeanstalkArgs._configure(_setter, **kwargs)
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
@@ -708,7 +586,6 @@ def _internal_init(__self__,
__props__.__dict__["beanstalk_environment_id"] = beanstalk_environment_id
__props__.__dict__["beanstalk_environment_name"] = beanstalk_environment_name
- deployment_preferences = _utilities.configure(deployment_preferences, BeanstalkDeploymentPreferencesArgs, True)
__props__.__dict__["deployment_preferences"] = deployment_preferences
if desired_capacity is None and not opts.urn:
raise TypeError("Missing required property 'desired_capacity'")
@@ -717,7 +594,6 @@ def _internal_init(__self__,
raise TypeError("Missing required property 'instance_types_spots'")
__props__.__dict__["instance_types_spots"] = instance_types_spots
__props__.__dict__["maintenance"] = maintenance
- managed_actions = _utilities.configure(managed_actions, BeanstalkManagedActionsArgs, True)
__props__.__dict__["managed_actions"] = managed_actions
if max_size is None and not opts.urn:
raise TypeError("Missing required property 'max_size'")
diff --git a/sdk/python/pulumi_spotinst/aws/credentials.py b/sdk/python/pulumi_spotinst/aws/credentials.py
index ba8b2f20..d0bf13fd 100644
--- a/sdk/python/pulumi_spotinst/aws/credentials.py
+++ b/sdk/python/pulumi_spotinst/aws/credentials.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
__all__ = ['CredentialsArgs', 'Credentials']
@@ -20,27 +20,8 @@ def __init__(__self__, *,
The set of arguments for constructing a Credentials resource.
:param pulumi.Input[str] iamrole: Provide the IAM Role ARN connected to another AWS account 922761411349 and with the latest Spot Policy - https://docs.spot.io/administration/api/spot-policy-in-aws
"""
- CredentialsArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- account_id=account_id,
- iamrole=iamrole,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- account_id: Optional[pulumi.Input[str]] = None,
- iamrole: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if account_id is None and 'accountId' in kwargs:
- account_id = kwargs['accountId']
- if account_id is None:
- raise TypeError("Missing 'account_id' argument")
- if iamrole is None:
- raise TypeError("Missing 'iamrole' argument")
-
- _setter("account_id", account_id)
- _setter("iamrole", iamrole)
+ pulumi.set(__self__, "account_id", account_id)
+ pulumi.set(__self__, "iamrole", iamrole)
@property
@pulumi.getter(name="accountId")
@@ -73,25 +54,10 @@ def __init__(__self__, *,
Input properties used for looking up and filtering Credentials resources.
:param pulumi.Input[str] iamrole: Provide the IAM Role ARN connected to another AWS account 922761411349 and with the latest Spot Policy - https://docs.spot.io/administration/api/spot-policy-in-aws
"""
- _CredentialsState._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- account_id=account_id,
- iamrole=iamrole,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- account_id: Optional[pulumi.Input[str]] = None,
- iamrole: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if account_id is None and 'accountId' in kwargs:
- account_id = kwargs['accountId']
-
if account_id is not None:
- _setter("account_id", account_id)
+ pulumi.set(__self__, "account_id", account_id)
if iamrole is not None:
- _setter("iamrole", iamrole)
+ pulumi.set(__self__, "iamrole", iamrole)
@property
@pulumi.getter(name="accountId")
@@ -173,10 +139,6 @@ def __init__(__self__, resource_name: str, *args, **kwargs):
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
- kwargs = kwargs or {}
- def _setter(key, value):
- kwargs[key] = value
- CredentialsArgs._configure(_setter, **kwargs)
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
diff --git a/sdk/python/pulumi_spotinst/aws/elastigroup.py b/sdk/python/pulumi_spotinst/aws/elastigroup.py
index 43721f76..65dd991d 100644
--- a/sdk/python/pulumi_spotinst/aws/elastigroup.py
+++ b/sdk/python/pulumi_spotinst/aws/elastigroup.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs
from ._inputs import *
@@ -180,499 +180,168 @@ def __init__(__self__, *,
:param pulumi.Input[int] wait_for_capacity: Minimum number of instances in a 'HEALTHY' status that is required before continuing. This is ignored when updating with blue/green deployment. Cannot exceed `desired_capacity`.
:param pulumi.Input[int] wait_for_capacity_timeout: Time (seconds) to wait for instances to report a 'HEALTHY' status. Useful for plans with multiple dependencies that take some time to initialize. Leave undefined or set to `0` to indicate no wait. This is ignored when updating with blue/green deployment.
"""
- ElastigroupArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- fallback_to_ondemand=fallback_to_ondemand,
- orientation=orientation,
- product=product,
- security_groups=security_groups,
- availability_zones=availability_zones,
- block_devices_mode=block_devices_mode,
- capacity_unit=capacity_unit,
- consider_od_pricing=consider_od_pricing,
- cpu_credits=cpu_credits,
- cpu_options=cpu_options,
- description=description,
- desired_capacity=desired_capacity,
- draining_timeout=draining_timeout,
- ebs_block_devices=ebs_block_devices,
- ebs_optimized=ebs_optimized,
- elastic_ips=elastic_ips,
- elastic_load_balancers=elastic_load_balancers,
- enable_monitoring=enable_monitoring,
- ephemeral_block_devices=ephemeral_block_devices,
- health_check_grace_period=health_check_grace_period,
- health_check_type=health_check_type,
- health_check_unhealthy_duration_before_replacement=health_check_unhealthy_duration_before_replacement,
- iam_instance_profile=iam_instance_profile,
- image_id=image_id,
- images=images,
- immediate_od_recover_threshold=immediate_od_recover_threshold,
- instance_types_ondemand=instance_types_ondemand,
- instance_types_preferred_spots=instance_types_preferred_spots,
- instance_types_spots=instance_types_spots,
- instance_types_weights=instance_types_weights,
- integration_beanstalk=integration_beanstalk,
- integration_codedeploy=integration_codedeploy,
- integration_docker_swarm=integration_docker_swarm,
- integration_ecs=integration_ecs,
- integration_gitlab=integration_gitlab,
- integration_kubernetes=integration_kubernetes,
- integration_mesosphere=integration_mesosphere,
- integration_multai_runtime=integration_multai_runtime,
- integration_nomad=integration_nomad,
- integration_rancher=integration_rancher,
- integration_route53=integration_route53,
- itfs=itfs,
- key_name=key_name,
- lifetime_period=lifetime_period,
- max_size=max_size,
- metadata_options=metadata_options,
- min_size=min_size,
- minimum_instance_lifetime=minimum_instance_lifetime,
- multai_target_sets=multai_target_sets,
- multiple_metrics=multiple_metrics,
- name=name,
- network_interfaces=network_interfaces,
- on_demand_types=on_demand_types,
- ondemand_count=ondemand_count,
- persist_block_devices=persist_block_devices,
- persist_private_ip=persist_private_ip,
- persist_root_device=persist_root_device,
- placement_tenancy=placement_tenancy,
- preferred_availability_zones=preferred_availability_zones,
- private_ips=private_ips,
- region=region,
- resource_requirements=resource_requirements,
- resource_tag_specifications=resource_tag_specifications,
- revert_to_spot=revert_to_spot,
- scaling_down_policies=scaling_down_policies,
- scaling_strategies=scaling_strategies,
- scaling_target_policies=scaling_target_policies,
- scaling_up_policies=scaling_up_policies,
- scheduled_tasks=scheduled_tasks,
- shutdown_script=shutdown_script,
- signals=signals,
- spot_percentage=spot_percentage,
- stateful_deallocation=stateful_deallocation,
- stateful_instance_actions=stateful_instance_actions,
- subnet_ids=subnet_ids,
- tags=tags,
- target_group_arns=target_group_arns,
- update_policy=update_policy,
- user_data=user_data,
- utilize_commitments=utilize_commitments,
- utilize_reserved_instances=utilize_reserved_instances,
- wait_for_capacity=wait_for_capacity,
- wait_for_capacity_timeout=wait_for_capacity_timeout,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- fallback_to_ondemand: Optional[pulumi.Input[bool]] = None,
- orientation: Optional[pulumi.Input[str]] = None,
- product: Optional[pulumi.Input[str]] = None,
- security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- block_devices_mode: Optional[pulumi.Input[str]] = None,
- capacity_unit: Optional[pulumi.Input[str]] = None,
- consider_od_pricing: Optional[pulumi.Input[bool]] = None,
- cpu_credits: Optional[pulumi.Input[str]] = None,
- cpu_options: Optional[pulumi.Input['ElastigroupCpuOptionsArgs']] = None,
- description: Optional[pulumi.Input[str]] = None,
- desired_capacity: Optional[pulumi.Input[int]] = None,
- draining_timeout: Optional[pulumi.Input[int]] = None,
- ebs_block_devices: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupEbsBlockDeviceArgs']]]] = None,
- ebs_optimized: Optional[pulumi.Input[bool]] = None,
- elastic_ips: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- elastic_load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- enable_monitoring: Optional[pulumi.Input[bool]] = None,
- ephemeral_block_devices: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupEphemeralBlockDeviceArgs']]]] = None,
- health_check_grace_period: Optional[pulumi.Input[int]] = None,
- health_check_type: Optional[pulumi.Input[str]] = None,
- health_check_unhealthy_duration_before_replacement: Optional[pulumi.Input[int]] = None,
- iam_instance_profile: Optional[pulumi.Input[str]] = None,
- image_id: Optional[pulumi.Input[str]] = None,
- images: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupImageArgs']]]] = None,
- immediate_od_recover_threshold: Optional[pulumi.Input[int]] = None,
- instance_types_ondemand: Optional[pulumi.Input[str]] = None,
- instance_types_preferred_spots: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- instance_types_spots: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- instance_types_weights: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupInstanceTypesWeightArgs']]]] = None,
- integration_beanstalk: Optional[pulumi.Input['ElastigroupIntegrationBeanstalkArgs']] = None,
- integration_codedeploy: Optional[pulumi.Input['ElastigroupIntegrationCodedeployArgs']] = None,
- integration_docker_swarm: Optional[pulumi.Input['ElastigroupIntegrationDockerSwarmArgs']] = None,
- integration_ecs: Optional[pulumi.Input['ElastigroupIntegrationEcsArgs']] = None,
- integration_gitlab: Optional[pulumi.Input['ElastigroupIntegrationGitlabArgs']] = None,
- integration_kubernetes: Optional[pulumi.Input['ElastigroupIntegrationKubernetesArgs']] = None,
- integration_mesosphere: Optional[pulumi.Input['ElastigroupIntegrationMesosphereArgs']] = None,
- integration_multai_runtime: Optional[pulumi.Input['ElastigroupIntegrationMultaiRuntimeArgs']] = None,
- integration_nomad: Optional[pulumi.Input['ElastigroupIntegrationNomadArgs']] = None,
- integration_rancher: Optional[pulumi.Input['ElastigroupIntegrationRancherArgs']] = None,
- integration_route53: Optional[pulumi.Input['ElastigroupIntegrationRoute53Args']] = None,
- itfs: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupItfArgs']]]] = None,
- key_name: Optional[pulumi.Input[str]] = None,
- lifetime_period: Optional[pulumi.Input[str]] = None,
- max_size: Optional[pulumi.Input[int]] = None,
- metadata_options: Optional[pulumi.Input['ElastigroupMetadataOptionsArgs']] = None,
- min_size: Optional[pulumi.Input[int]] = None,
- minimum_instance_lifetime: Optional[pulumi.Input[int]] = None,
- multai_target_sets: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupMultaiTargetSetArgs']]]] = None,
- multiple_metrics: Optional[pulumi.Input['ElastigroupMultipleMetricsArgs']] = None,
- name: Optional[pulumi.Input[str]] = None,
- network_interfaces: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceArgs']]]] = None,
- on_demand_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- ondemand_count: Optional[pulumi.Input[int]] = None,
- persist_block_devices: Optional[pulumi.Input[bool]] = None,
- persist_private_ip: Optional[pulumi.Input[bool]] = None,
- persist_root_device: Optional[pulumi.Input[bool]] = None,
- placement_tenancy: Optional[pulumi.Input[str]] = None,
- preferred_availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- private_ips: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- region: Optional[pulumi.Input[str]] = None,
- resource_requirements: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupResourceRequirementArgs']]]] = None,
- resource_tag_specifications: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupResourceTagSpecificationArgs']]]] = None,
- revert_to_spot: Optional[pulumi.Input['ElastigroupRevertToSpotArgs']] = None,
- scaling_down_policies: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyArgs']]]] = None,
- scaling_strategies: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingStrategyArgs']]]] = None,
- scaling_target_policies: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingTargetPolicyArgs']]]] = None,
- scaling_up_policies: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyArgs']]]] = None,
- scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScheduledTaskArgs']]]] = None,
- shutdown_script: Optional[pulumi.Input[str]] = None,
- signals: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupSignalArgs']]]] = None,
- spot_percentage: Optional[pulumi.Input[int]] = None,
- stateful_deallocation: Optional[pulumi.Input['ElastigroupStatefulDeallocationArgs']] = None,
- stateful_instance_actions: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupStatefulInstanceActionArgs']]]] = None,
- subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- tags: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupTagArgs']]]] = None,
- target_group_arns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- update_policy: Optional[pulumi.Input['ElastigroupUpdatePolicyArgs']] = None,
- user_data: Optional[pulumi.Input[str]] = None,
- utilize_commitments: Optional[pulumi.Input[bool]] = None,
- utilize_reserved_instances: Optional[pulumi.Input[bool]] = None,
- wait_for_capacity: Optional[pulumi.Input[int]] = None,
- wait_for_capacity_timeout: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if fallback_to_ondemand is None and 'fallbackToOndemand' in kwargs:
- fallback_to_ondemand = kwargs['fallbackToOndemand']
- if fallback_to_ondemand is None:
- raise TypeError("Missing 'fallback_to_ondemand' argument")
- if orientation is None:
- raise TypeError("Missing 'orientation' argument")
- if product is None:
- raise TypeError("Missing 'product' argument")
- if security_groups is None and 'securityGroups' in kwargs:
- security_groups = kwargs['securityGroups']
- if security_groups is None:
- raise TypeError("Missing 'security_groups' argument")
- if availability_zones is None and 'availabilityZones' in kwargs:
- availability_zones = kwargs['availabilityZones']
- if block_devices_mode is None and 'blockDevicesMode' in kwargs:
- block_devices_mode = kwargs['blockDevicesMode']
- if capacity_unit is None and 'capacityUnit' in kwargs:
- capacity_unit = kwargs['capacityUnit']
- if consider_od_pricing is None and 'considerOdPricing' in kwargs:
- consider_od_pricing = kwargs['considerOdPricing']
- if cpu_credits is None and 'cpuCredits' in kwargs:
- cpu_credits = kwargs['cpuCredits']
- if cpu_options is None and 'cpuOptions' in kwargs:
- cpu_options = kwargs['cpuOptions']
- if desired_capacity is None and 'desiredCapacity' in kwargs:
- desired_capacity = kwargs['desiredCapacity']
- if draining_timeout is None and 'drainingTimeout' in kwargs:
- draining_timeout = kwargs['drainingTimeout']
- if ebs_block_devices is None and 'ebsBlockDevices' in kwargs:
- ebs_block_devices = kwargs['ebsBlockDevices']
- if ebs_optimized is None and 'ebsOptimized' in kwargs:
- ebs_optimized = kwargs['ebsOptimized']
- if elastic_ips is None and 'elasticIps' in kwargs:
- elastic_ips = kwargs['elasticIps']
- if elastic_load_balancers is None and 'elasticLoadBalancers' in kwargs:
- elastic_load_balancers = kwargs['elasticLoadBalancers']
- if enable_monitoring is None and 'enableMonitoring' in kwargs:
- enable_monitoring = kwargs['enableMonitoring']
- if ephemeral_block_devices is None and 'ephemeralBlockDevices' in kwargs:
- ephemeral_block_devices = kwargs['ephemeralBlockDevices']
- if health_check_grace_period is None and 'healthCheckGracePeriod' in kwargs:
- health_check_grace_period = kwargs['healthCheckGracePeriod']
- if health_check_type is None and 'healthCheckType' in kwargs:
- health_check_type = kwargs['healthCheckType']
- if health_check_unhealthy_duration_before_replacement is None and 'healthCheckUnhealthyDurationBeforeReplacement' in kwargs:
- health_check_unhealthy_duration_before_replacement = kwargs['healthCheckUnhealthyDurationBeforeReplacement']
- if iam_instance_profile is None and 'iamInstanceProfile' in kwargs:
- iam_instance_profile = kwargs['iamInstanceProfile']
- if image_id is None and 'imageId' in kwargs:
- image_id = kwargs['imageId']
- if immediate_od_recover_threshold is None and 'immediateOdRecoverThreshold' in kwargs:
- immediate_od_recover_threshold = kwargs['immediateOdRecoverThreshold']
- if instance_types_ondemand is None and 'instanceTypesOndemand' in kwargs:
- instance_types_ondemand = kwargs['instanceTypesOndemand']
- if instance_types_preferred_spots is None and 'instanceTypesPreferredSpots' in kwargs:
- instance_types_preferred_spots = kwargs['instanceTypesPreferredSpots']
- if instance_types_spots is None and 'instanceTypesSpots' in kwargs:
- instance_types_spots = kwargs['instanceTypesSpots']
- if instance_types_weights is None and 'instanceTypesWeights' in kwargs:
- instance_types_weights = kwargs['instanceTypesWeights']
- if integration_beanstalk is None and 'integrationBeanstalk' in kwargs:
- integration_beanstalk = kwargs['integrationBeanstalk']
- if integration_codedeploy is None and 'integrationCodedeploy' in kwargs:
- integration_codedeploy = kwargs['integrationCodedeploy']
- if integration_docker_swarm is None and 'integrationDockerSwarm' in kwargs:
- integration_docker_swarm = kwargs['integrationDockerSwarm']
- if integration_ecs is None and 'integrationEcs' in kwargs:
- integration_ecs = kwargs['integrationEcs']
- if integration_gitlab is None and 'integrationGitlab' in kwargs:
- integration_gitlab = kwargs['integrationGitlab']
- if integration_kubernetes is None and 'integrationKubernetes' in kwargs:
- integration_kubernetes = kwargs['integrationKubernetes']
- if integration_mesosphere is None and 'integrationMesosphere' in kwargs:
- integration_mesosphere = kwargs['integrationMesosphere']
- if integration_multai_runtime is None and 'integrationMultaiRuntime' in kwargs:
- integration_multai_runtime = kwargs['integrationMultaiRuntime']
- if integration_nomad is None and 'integrationNomad' in kwargs:
- integration_nomad = kwargs['integrationNomad']
- if integration_rancher is None and 'integrationRancher' in kwargs:
- integration_rancher = kwargs['integrationRancher']
- if integration_route53 is None and 'integrationRoute53' in kwargs:
- integration_route53 = kwargs['integrationRoute53']
- if key_name is None and 'keyName' in kwargs:
- key_name = kwargs['keyName']
- if lifetime_period is None and 'lifetimePeriod' in kwargs:
- lifetime_period = kwargs['lifetimePeriod']
- if max_size is None and 'maxSize' in kwargs:
- max_size = kwargs['maxSize']
- if metadata_options is None and 'metadataOptions' in kwargs:
- metadata_options = kwargs['metadataOptions']
- if min_size is None and 'minSize' in kwargs:
- min_size = kwargs['minSize']
- if minimum_instance_lifetime is None and 'minimumInstanceLifetime' in kwargs:
- minimum_instance_lifetime = kwargs['minimumInstanceLifetime']
- if multai_target_sets is None and 'multaiTargetSets' in kwargs:
- multai_target_sets = kwargs['multaiTargetSets']
- if multiple_metrics is None and 'multipleMetrics' in kwargs:
- multiple_metrics = kwargs['multipleMetrics']
- if network_interfaces is None and 'networkInterfaces' in kwargs:
- network_interfaces = kwargs['networkInterfaces']
- if on_demand_types is None and 'onDemandTypes' in kwargs:
- on_demand_types = kwargs['onDemandTypes']
- if ondemand_count is None and 'ondemandCount' in kwargs:
- ondemand_count = kwargs['ondemandCount']
- if persist_block_devices is None and 'persistBlockDevices' in kwargs:
- persist_block_devices = kwargs['persistBlockDevices']
- if persist_private_ip is None and 'persistPrivateIp' in kwargs:
- persist_private_ip = kwargs['persistPrivateIp']
- if persist_root_device is None and 'persistRootDevice' in kwargs:
- persist_root_device = kwargs['persistRootDevice']
- if placement_tenancy is None and 'placementTenancy' in kwargs:
- placement_tenancy = kwargs['placementTenancy']
- if preferred_availability_zones is None and 'preferredAvailabilityZones' in kwargs:
- preferred_availability_zones = kwargs['preferredAvailabilityZones']
- if private_ips is None and 'privateIps' in kwargs:
- private_ips = kwargs['privateIps']
- if resource_requirements is None and 'resourceRequirements' in kwargs:
- resource_requirements = kwargs['resourceRequirements']
- if resource_tag_specifications is None and 'resourceTagSpecifications' in kwargs:
- resource_tag_specifications = kwargs['resourceTagSpecifications']
- if revert_to_spot is None and 'revertToSpot' in kwargs:
- revert_to_spot = kwargs['revertToSpot']
- if scaling_down_policies is None and 'scalingDownPolicies' in kwargs:
- scaling_down_policies = kwargs['scalingDownPolicies']
- if scaling_strategies is None and 'scalingStrategies' in kwargs:
- scaling_strategies = kwargs['scalingStrategies']
- if scaling_target_policies is None and 'scalingTargetPolicies' in kwargs:
- scaling_target_policies = kwargs['scalingTargetPolicies']
- if scaling_up_policies is None and 'scalingUpPolicies' in kwargs:
- scaling_up_policies = kwargs['scalingUpPolicies']
- if scheduled_tasks is None and 'scheduledTasks' in kwargs:
- scheduled_tasks = kwargs['scheduledTasks']
- if shutdown_script is None and 'shutdownScript' in kwargs:
- shutdown_script = kwargs['shutdownScript']
- if spot_percentage is None and 'spotPercentage' in kwargs:
- spot_percentage = kwargs['spotPercentage']
- if stateful_deallocation is None and 'statefulDeallocation' in kwargs:
- stateful_deallocation = kwargs['statefulDeallocation']
- if stateful_instance_actions is None and 'statefulInstanceActions' in kwargs:
- stateful_instance_actions = kwargs['statefulInstanceActions']
- if subnet_ids is None and 'subnetIds' in kwargs:
- subnet_ids = kwargs['subnetIds']
- if target_group_arns is None and 'targetGroupArns' in kwargs:
- target_group_arns = kwargs['targetGroupArns']
- if update_policy is None and 'updatePolicy' in kwargs:
- update_policy = kwargs['updatePolicy']
- if user_data is None and 'userData' in kwargs:
- user_data = kwargs['userData']
- if utilize_commitments is None and 'utilizeCommitments' in kwargs:
- utilize_commitments = kwargs['utilizeCommitments']
- if utilize_reserved_instances is None and 'utilizeReservedInstances' in kwargs:
- utilize_reserved_instances = kwargs['utilizeReservedInstances']
- if wait_for_capacity is None and 'waitForCapacity' in kwargs:
- wait_for_capacity = kwargs['waitForCapacity']
- if wait_for_capacity_timeout is None and 'waitForCapacityTimeout' in kwargs:
- wait_for_capacity_timeout = kwargs['waitForCapacityTimeout']
-
- _setter("fallback_to_ondemand", fallback_to_ondemand)
- _setter("orientation", orientation)
- _setter("product", product)
- _setter("security_groups", security_groups)
+ pulumi.set(__self__, "fallback_to_ondemand", fallback_to_ondemand)
+ pulumi.set(__self__, "orientation", orientation)
+ pulumi.set(__self__, "product", product)
+ pulumi.set(__self__, "security_groups", security_groups)
if availability_zones is not None:
- _setter("availability_zones", availability_zones)
+ pulumi.set(__self__, "availability_zones", availability_zones)
if block_devices_mode is not None:
- _setter("block_devices_mode", block_devices_mode)
+ pulumi.set(__self__, "block_devices_mode", block_devices_mode)
if capacity_unit is not None:
- _setter("capacity_unit", capacity_unit)
+ pulumi.set(__self__, "capacity_unit", capacity_unit)
if consider_od_pricing is not None:
- _setter("consider_od_pricing", consider_od_pricing)
+ pulumi.set(__self__, "consider_od_pricing", consider_od_pricing)
if cpu_credits is not None:
- _setter("cpu_credits", cpu_credits)
+ pulumi.set(__self__, "cpu_credits", cpu_credits)
if cpu_options is not None:
- _setter("cpu_options", cpu_options)
+ pulumi.set(__self__, "cpu_options", cpu_options)
if description is not None:
- _setter("description", description)
+ pulumi.set(__self__, "description", description)
if desired_capacity is not None:
- _setter("desired_capacity", desired_capacity)
+ pulumi.set(__self__, "desired_capacity", desired_capacity)
if draining_timeout is not None:
- _setter("draining_timeout", draining_timeout)
+ pulumi.set(__self__, "draining_timeout", draining_timeout)
if ebs_block_devices is not None:
- _setter("ebs_block_devices", ebs_block_devices)
+ pulumi.set(__self__, "ebs_block_devices", ebs_block_devices)
if ebs_optimized is not None:
- _setter("ebs_optimized", ebs_optimized)
+ pulumi.set(__self__, "ebs_optimized", ebs_optimized)
if elastic_ips is not None:
- _setter("elastic_ips", elastic_ips)
+ pulumi.set(__self__, "elastic_ips", elastic_ips)
if elastic_load_balancers is not None:
- _setter("elastic_load_balancers", elastic_load_balancers)
+ pulumi.set(__self__, "elastic_load_balancers", elastic_load_balancers)
if enable_monitoring is not None:
- _setter("enable_monitoring", enable_monitoring)
+ pulumi.set(__self__, "enable_monitoring", enable_monitoring)
if ephemeral_block_devices is not None:
- _setter("ephemeral_block_devices", ephemeral_block_devices)
+ pulumi.set(__self__, "ephemeral_block_devices", ephemeral_block_devices)
if health_check_grace_period is not None:
- _setter("health_check_grace_period", health_check_grace_period)
+ pulumi.set(__self__, "health_check_grace_period", health_check_grace_period)
if health_check_type is not None:
- _setter("health_check_type", health_check_type)
+ pulumi.set(__self__, "health_check_type", health_check_type)
if health_check_unhealthy_duration_before_replacement is not None:
- _setter("health_check_unhealthy_duration_before_replacement", health_check_unhealthy_duration_before_replacement)
+ pulumi.set(__self__, "health_check_unhealthy_duration_before_replacement", health_check_unhealthy_duration_before_replacement)
if iam_instance_profile is not None:
- _setter("iam_instance_profile", iam_instance_profile)
+ pulumi.set(__self__, "iam_instance_profile", iam_instance_profile)
if image_id is not None:
- _setter("image_id", image_id)
+ pulumi.set(__self__, "image_id", image_id)
if images is not None:
- _setter("images", images)
+ pulumi.set(__self__, "images", images)
if immediate_od_recover_threshold is not None:
- _setter("immediate_od_recover_threshold", immediate_od_recover_threshold)
+ pulumi.set(__self__, "immediate_od_recover_threshold", immediate_od_recover_threshold)
if instance_types_ondemand is not None:
- _setter("instance_types_ondemand", instance_types_ondemand)
+ pulumi.set(__self__, "instance_types_ondemand", instance_types_ondemand)
if instance_types_preferred_spots is not None:
- _setter("instance_types_preferred_spots", instance_types_preferred_spots)
+ pulumi.set(__self__, "instance_types_preferred_spots", instance_types_preferred_spots)
if instance_types_spots is not None:
- _setter("instance_types_spots", instance_types_spots)
+ pulumi.set(__self__, "instance_types_spots", instance_types_spots)
if instance_types_weights is not None:
- _setter("instance_types_weights", instance_types_weights)
+ pulumi.set(__self__, "instance_types_weights", instance_types_weights)
if integration_beanstalk is not None:
- _setter("integration_beanstalk", integration_beanstalk)
+ pulumi.set(__self__, "integration_beanstalk", integration_beanstalk)
if integration_codedeploy is not None:
- _setter("integration_codedeploy", integration_codedeploy)
+ pulumi.set(__self__, "integration_codedeploy", integration_codedeploy)
if integration_docker_swarm is not None:
- _setter("integration_docker_swarm", integration_docker_swarm)
+ pulumi.set(__self__, "integration_docker_swarm", integration_docker_swarm)
if integration_ecs is not None:
- _setter("integration_ecs", integration_ecs)
+ pulumi.set(__self__, "integration_ecs", integration_ecs)
if integration_gitlab is not None:
- _setter("integration_gitlab", integration_gitlab)
+ pulumi.set(__self__, "integration_gitlab", integration_gitlab)
if integration_kubernetes is not None:
- _setter("integration_kubernetes", integration_kubernetes)
+ pulumi.set(__self__, "integration_kubernetes", integration_kubernetes)
if integration_mesosphere is not None:
- _setter("integration_mesosphere", integration_mesosphere)
+ pulumi.set(__self__, "integration_mesosphere", integration_mesosphere)
if integration_multai_runtime is not None:
- _setter("integration_multai_runtime", integration_multai_runtime)
+ pulumi.set(__self__, "integration_multai_runtime", integration_multai_runtime)
if integration_nomad is not None:
- _setter("integration_nomad", integration_nomad)
+ pulumi.set(__self__, "integration_nomad", integration_nomad)
if integration_rancher is not None:
- _setter("integration_rancher", integration_rancher)
+ pulumi.set(__self__, "integration_rancher", integration_rancher)
if integration_route53 is not None:
- _setter("integration_route53", integration_route53)
+ pulumi.set(__self__, "integration_route53", integration_route53)
if itfs is not None:
- _setter("itfs", itfs)
+ pulumi.set(__self__, "itfs", itfs)
if key_name is not None:
- _setter("key_name", key_name)
+ pulumi.set(__self__, "key_name", key_name)
if lifetime_period is not None:
- _setter("lifetime_period", lifetime_period)
+ pulumi.set(__self__, "lifetime_period", lifetime_period)
if max_size is not None:
- _setter("max_size", max_size)
+ pulumi.set(__self__, "max_size", max_size)
if metadata_options is not None:
- _setter("metadata_options", metadata_options)
+ pulumi.set(__self__, "metadata_options", metadata_options)
if min_size is not None:
- _setter("min_size", min_size)
+ pulumi.set(__self__, "min_size", min_size)
if minimum_instance_lifetime is not None:
- _setter("minimum_instance_lifetime", minimum_instance_lifetime)
+ pulumi.set(__self__, "minimum_instance_lifetime", minimum_instance_lifetime)
if multai_target_sets is not None:
- _setter("multai_target_sets", multai_target_sets)
+ pulumi.set(__self__, "multai_target_sets", multai_target_sets)
if multiple_metrics is not None:
- _setter("multiple_metrics", multiple_metrics)
+ pulumi.set(__self__, "multiple_metrics", multiple_metrics)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if network_interfaces is not None:
- _setter("network_interfaces", network_interfaces)
+ pulumi.set(__self__, "network_interfaces", network_interfaces)
if on_demand_types is not None:
- _setter("on_demand_types", on_demand_types)
+ pulumi.set(__self__, "on_demand_types", on_demand_types)
if ondemand_count is not None:
- _setter("ondemand_count", ondemand_count)
+ pulumi.set(__self__, "ondemand_count", ondemand_count)
if persist_block_devices is not None:
- _setter("persist_block_devices", persist_block_devices)
+ pulumi.set(__self__, "persist_block_devices", persist_block_devices)
if persist_private_ip is not None:
- _setter("persist_private_ip", persist_private_ip)
+ pulumi.set(__self__, "persist_private_ip", persist_private_ip)
if persist_root_device is not None:
- _setter("persist_root_device", persist_root_device)
+ pulumi.set(__self__, "persist_root_device", persist_root_device)
if placement_tenancy is not None:
- _setter("placement_tenancy", placement_tenancy)
+ pulumi.set(__self__, "placement_tenancy", placement_tenancy)
if preferred_availability_zones is not None:
- _setter("preferred_availability_zones", preferred_availability_zones)
+ pulumi.set(__self__, "preferred_availability_zones", preferred_availability_zones)
if private_ips is not None:
- _setter("private_ips", private_ips)
+ pulumi.set(__self__, "private_ips", private_ips)
if region is not None:
- _setter("region", region)
+ pulumi.set(__self__, "region", region)
if resource_requirements is not None:
- _setter("resource_requirements", resource_requirements)
+ pulumi.set(__self__, "resource_requirements", resource_requirements)
if resource_tag_specifications is not None:
- _setter("resource_tag_specifications", resource_tag_specifications)
+ pulumi.set(__self__, "resource_tag_specifications", resource_tag_specifications)
if revert_to_spot is not None:
- _setter("revert_to_spot", revert_to_spot)
+ pulumi.set(__self__, "revert_to_spot", revert_to_spot)
if scaling_down_policies is not None:
- _setter("scaling_down_policies", scaling_down_policies)
+ pulumi.set(__self__, "scaling_down_policies", scaling_down_policies)
if scaling_strategies is not None:
- _setter("scaling_strategies", scaling_strategies)
+ pulumi.set(__self__, "scaling_strategies", scaling_strategies)
if scaling_target_policies is not None:
- _setter("scaling_target_policies", scaling_target_policies)
+ pulumi.set(__self__, "scaling_target_policies", scaling_target_policies)
if scaling_up_policies is not None:
- _setter("scaling_up_policies", scaling_up_policies)
+ pulumi.set(__self__, "scaling_up_policies", scaling_up_policies)
if scheduled_tasks is not None:
- _setter("scheduled_tasks", scheduled_tasks)
+ pulumi.set(__self__, "scheduled_tasks", scheduled_tasks)
if shutdown_script is not None:
- _setter("shutdown_script", shutdown_script)
+ pulumi.set(__self__, "shutdown_script", shutdown_script)
if signals is not None:
- _setter("signals", signals)
+ pulumi.set(__self__, "signals", signals)
if spot_percentage is not None:
- _setter("spot_percentage", spot_percentage)
+ pulumi.set(__self__, "spot_percentage", spot_percentage)
if stateful_deallocation is not None:
- _setter("stateful_deallocation", stateful_deallocation)
+ pulumi.set(__self__, "stateful_deallocation", stateful_deallocation)
if stateful_instance_actions is not None:
- _setter("stateful_instance_actions", stateful_instance_actions)
+ pulumi.set(__self__, "stateful_instance_actions", stateful_instance_actions)
if subnet_ids is not None:
- _setter("subnet_ids", subnet_ids)
+ pulumi.set(__self__, "subnet_ids", subnet_ids)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
if target_group_arns is not None:
- _setter("target_group_arns", target_group_arns)
+ pulumi.set(__self__, "target_group_arns", target_group_arns)
if update_policy is not None:
- _setter("update_policy", update_policy)
+ pulumi.set(__self__, "update_policy", update_policy)
if user_data is not None:
- _setter("user_data", user_data)
+ pulumi.set(__self__, "user_data", user_data)
if utilize_commitments is not None:
- _setter("utilize_commitments", utilize_commitments)
+ pulumi.set(__self__, "utilize_commitments", utilize_commitments)
if utilize_reserved_instances is not None:
- _setter("utilize_reserved_instances", utilize_reserved_instances)
+ pulumi.set(__self__, "utilize_reserved_instances", utilize_reserved_instances)
if wait_for_capacity is not None:
- _setter("wait_for_capacity", wait_for_capacity)
+ pulumi.set(__self__, "wait_for_capacity", wait_for_capacity)
if wait_for_capacity_timeout is not None:
- _setter("wait_for_capacity_timeout", wait_for_capacity_timeout)
+ pulumi.set(__self__, "wait_for_capacity_timeout", wait_for_capacity_timeout)
@property
@pulumi.getter(name="fallbackToOndemand")
@@ -1797,495 +1466,172 @@ def __init__(__self__, *,
:param pulumi.Input[int] wait_for_capacity: Minimum number of instances in a 'HEALTHY' status that is required before continuing. This is ignored when updating with blue/green deployment. Cannot exceed `desired_capacity`.
:param pulumi.Input[int] wait_for_capacity_timeout: Time (seconds) to wait for instances to report a 'HEALTHY' status. Useful for plans with multiple dependencies that take some time to initialize. Leave undefined or set to `0` to indicate no wait. This is ignored when updating with blue/green deployment.
"""
- _ElastigroupState._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- availability_zones=availability_zones,
- block_devices_mode=block_devices_mode,
- capacity_unit=capacity_unit,
- consider_od_pricing=consider_od_pricing,
- cpu_credits=cpu_credits,
- cpu_options=cpu_options,
- description=description,
- desired_capacity=desired_capacity,
- draining_timeout=draining_timeout,
- ebs_block_devices=ebs_block_devices,
- ebs_optimized=ebs_optimized,
- elastic_ips=elastic_ips,
- elastic_load_balancers=elastic_load_balancers,
- enable_monitoring=enable_monitoring,
- ephemeral_block_devices=ephemeral_block_devices,
- fallback_to_ondemand=fallback_to_ondemand,
- health_check_grace_period=health_check_grace_period,
- health_check_type=health_check_type,
- health_check_unhealthy_duration_before_replacement=health_check_unhealthy_duration_before_replacement,
- iam_instance_profile=iam_instance_profile,
- image_id=image_id,
- images=images,
- immediate_od_recover_threshold=immediate_od_recover_threshold,
- instance_types_ondemand=instance_types_ondemand,
- instance_types_preferred_spots=instance_types_preferred_spots,
- instance_types_spots=instance_types_spots,
- instance_types_weights=instance_types_weights,
- integration_beanstalk=integration_beanstalk,
- integration_codedeploy=integration_codedeploy,
- integration_docker_swarm=integration_docker_swarm,
- integration_ecs=integration_ecs,
- integration_gitlab=integration_gitlab,
- integration_kubernetes=integration_kubernetes,
- integration_mesosphere=integration_mesosphere,
- integration_multai_runtime=integration_multai_runtime,
- integration_nomad=integration_nomad,
- integration_rancher=integration_rancher,
- integration_route53=integration_route53,
- itfs=itfs,
- key_name=key_name,
- lifetime_period=lifetime_period,
- max_size=max_size,
- metadata_options=metadata_options,
- min_size=min_size,
- minimum_instance_lifetime=minimum_instance_lifetime,
- multai_target_sets=multai_target_sets,
- multiple_metrics=multiple_metrics,
- name=name,
- network_interfaces=network_interfaces,
- on_demand_types=on_demand_types,
- ondemand_count=ondemand_count,
- orientation=orientation,
- persist_block_devices=persist_block_devices,
- persist_private_ip=persist_private_ip,
- persist_root_device=persist_root_device,
- placement_tenancy=placement_tenancy,
- preferred_availability_zones=preferred_availability_zones,
- private_ips=private_ips,
- product=product,
- region=region,
- resource_requirements=resource_requirements,
- resource_tag_specifications=resource_tag_specifications,
- revert_to_spot=revert_to_spot,
- scaling_down_policies=scaling_down_policies,
- scaling_strategies=scaling_strategies,
- scaling_target_policies=scaling_target_policies,
- scaling_up_policies=scaling_up_policies,
- scheduled_tasks=scheduled_tasks,
- security_groups=security_groups,
- shutdown_script=shutdown_script,
- signals=signals,
- spot_percentage=spot_percentage,
- stateful_deallocation=stateful_deallocation,
- stateful_instance_actions=stateful_instance_actions,
- subnet_ids=subnet_ids,
- tags=tags,
- target_group_arns=target_group_arns,
- update_policy=update_policy,
- user_data=user_data,
- utilize_commitments=utilize_commitments,
- utilize_reserved_instances=utilize_reserved_instances,
- wait_for_capacity=wait_for_capacity,
- wait_for_capacity_timeout=wait_for_capacity_timeout,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- block_devices_mode: Optional[pulumi.Input[str]] = None,
- capacity_unit: Optional[pulumi.Input[str]] = None,
- consider_od_pricing: Optional[pulumi.Input[bool]] = None,
- cpu_credits: Optional[pulumi.Input[str]] = None,
- cpu_options: Optional[pulumi.Input['ElastigroupCpuOptionsArgs']] = None,
- description: Optional[pulumi.Input[str]] = None,
- desired_capacity: Optional[pulumi.Input[int]] = None,
- draining_timeout: Optional[pulumi.Input[int]] = None,
- ebs_block_devices: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupEbsBlockDeviceArgs']]]] = None,
- ebs_optimized: Optional[pulumi.Input[bool]] = None,
- elastic_ips: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- elastic_load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- enable_monitoring: Optional[pulumi.Input[bool]] = None,
- ephemeral_block_devices: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupEphemeralBlockDeviceArgs']]]] = None,
- fallback_to_ondemand: Optional[pulumi.Input[bool]] = None,
- health_check_grace_period: Optional[pulumi.Input[int]] = None,
- health_check_type: Optional[pulumi.Input[str]] = None,
- health_check_unhealthy_duration_before_replacement: Optional[pulumi.Input[int]] = None,
- iam_instance_profile: Optional[pulumi.Input[str]] = None,
- image_id: Optional[pulumi.Input[str]] = None,
- images: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupImageArgs']]]] = None,
- immediate_od_recover_threshold: Optional[pulumi.Input[int]] = None,
- instance_types_ondemand: Optional[pulumi.Input[str]] = None,
- instance_types_preferred_spots: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- instance_types_spots: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- instance_types_weights: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupInstanceTypesWeightArgs']]]] = None,
- integration_beanstalk: Optional[pulumi.Input['ElastigroupIntegrationBeanstalkArgs']] = None,
- integration_codedeploy: Optional[pulumi.Input['ElastigroupIntegrationCodedeployArgs']] = None,
- integration_docker_swarm: Optional[pulumi.Input['ElastigroupIntegrationDockerSwarmArgs']] = None,
- integration_ecs: Optional[pulumi.Input['ElastigroupIntegrationEcsArgs']] = None,
- integration_gitlab: Optional[pulumi.Input['ElastigroupIntegrationGitlabArgs']] = None,
- integration_kubernetes: Optional[pulumi.Input['ElastigroupIntegrationKubernetesArgs']] = None,
- integration_mesosphere: Optional[pulumi.Input['ElastigroupIntegrationMesosphereArgs']] = None,
- integration_multai_runtime: Optional[pulumi.Input['ElastigroupIntegrationMultaiRuntimeArgs']] = None,
- integration_nomad: Optional[pulumi.Input['ElastigroupIntegrationNomadArgs']] = None,
- integration_rancher: Optional[pulumi.Input['ElastigroupIntegrationRancherArgs']] = None,
- integration_route53: Optional[pulumi.Input['ElastigroupIntegrationRoute53Args']] = None,
- itfs: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupItfArgs']]]] = None,
- key_name: Optional[pulumi.Input[str]] = None,
- lifetime_period: Optional[pulumi.Input[str]] = None,
- max_size: Optional[pulumi.Input[int]] = None,
- metadata_options: Optional[pulumi.Input['ElastigroupMetadataOptionsArgs']] = None,
- min_size: Optional[pulumi.Input[int]] = None,
- minimum_instance_lifetime: Optional[pulumi.Input[int]] = None,
- multai_target_sets: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupMultaiTargetSetArgs']]]] = None,
- multiple_metrics: Optional[pulumi.Input['ElastigroupMultipleMetricsArgs']] = None,
- name: Optional[pulumi.Input[str]] = None,
- network_interfaces: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceArgs']]]] = None,
- on_demand_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- ondemand_count: Optional[pulumi.Input[int]] = None,
- orientation: Optional[pulumi.Input[str]] = None,
- persist_block_devices: Optional[pulumi.Input[bool]] = None,
- persist_private_ip: Optional[pulumi.Input[bool]] = None,
- persist_root_device: Optional[pulumi.Input[bool]] = None,
- placement_tenancy: Optional[pulumi.Input[str]] = None,
- preferred_availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- private_ips: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- product: Optional[pulumi.Input[str]] = None,
- region: Optional[pulumi.Input[str]] = None,
- resource_requirements: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupResourceRequirementArgs']]]] = None,
- resource_tag_specifications: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupResourceTagSpecificationArgs']]]] = None,
- revert_to_spot: Optional[pulumi.Input['ElastigroupRevertToSpotArgs']] = None,
- scaling_down_policies: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyArgs']]]] = None,
- scaling_strategies: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingStrategyArgs']]]] = None,
- scaling_target_policies: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingTargetPolicyArgs']]]] = None,
- scaling_up_policies: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyArgs']]]] = None,
- scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScheduledTaskArgs']]]] = None,
- security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- shutdown_script: Optional[pulumi.Input[str]] = None,
- signals: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupSignalArgs']]]] = None,
- spot_percentage: Optional[pulumi.Input[int]] = None,
- stateful_deallocation: Optional[pulumi.Input['ElastigroupStatefulDeallocationArgs']] = None,
- stateful_instance_actions: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupStatefulInstanceActionArgs']]]] = None,
- subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- tags: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupTagArgs']]]] = None,
- target_group_arns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- update_policy: Optional[pulumi.Input['ElastigroupUpdatePolicyArgs']] = None,
- user_data: Optional[pulumi.Input[str]] = None,
- utilize_commitments: Optional[pulumi.Input[bool]] = None,
- utilize_reserved_instances: Optional[pulumi.Input[bool]] = None,
- wait_for_capacity: Optional[pulumi.Input[int]] = None,
- wait_for_capacity_timeout: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if availability_zones is None and 'availabilityZones' in kwargs:
- availability_zones = kwargs['availabilityZones']
- if block_devices_mode is None and 'blockDevicesMode' in kwargs:
- block_devices_mode = kwargs['blockDevicesMode']
- if capacity_unit is None and 'capacityUnit' in kwargs:
- capacity_unit = kwargs['capacityUnit']
- if consider_od_pricing is None and 'considerOdPricing' in kwargs:
- consider_od_pricing = kwargs['considerOdPricing']
- if cpu_credits is None and 'cpuCredits' in kwargs:
- cpu_credits = kwargs['cpuCredits']
- if cpu_options is None and 'cpuOptions' in kwargs:
- cpu_options = kwargs['cpuOptions']
- if desired_capacity is None and 'desiredCapacity' in kwargs:
- desired_capacity = kwargs['desiredCapacity']
- if draining_timeout is None and 'drainingTimeout' in kwargs:
- draining_timeout = kwargs['drainingTimeout']
- if ebs_block_devices is None and 'ebsBlockDevices' in kwargs:
- ebs_block_devices = kwargs['ebsBlockDevices']
- if ebs_optimized is None and 'ebsOptimized' in kwargs:
- ebs_optimized = kwargs['ebsOptimized']
- if elastic_ips is None and 'elasticIps' in kwargs:
- elastic_ips = kwargs['elasticIps']
- if elastic_load_balancers is None and 'elasticLoadBalancers' in kwargs:
- elastic_load_balancers = kwargs['elasticLoadBalancers']
- if enable_monitoring is None and 'enableMonitoring' in kwargs:
- enable_monitoring = kwargs['enableMonitoring']
- if ephemeral_block_devices is None and 'ephemeralBlockDevices' in kwargs:
- ephemeral_block_devices = kwargs['ephemeralBlockDevices']
- if fallback_to_ondemand is None and 'fallbackToOndemand' in kwargs:
- fallback_to_ondemand = kwargs['fallbackToOndemand']
- if health_check_grace_period is None and 'healthCheckGracePeriod' in kwargs:
- health_check_grace_period = kwargs['healthCheckGracePeriod']
- if health_check_type is None and 'healthCheckType' in kwargs:
- health_check_type = kwargs['healthCheckType']
- if health_check_unhealthy_duration_before_replacement is None and 'healthCheckUnhealthyDurationBeforeReplacement' in kwargs:
- health_check_unhealthy_duration_before_replacement = kwargs['healthCheckUnhealthyDurationBeforeReplacement']
- if iam_instance_profile is None and 'iamInstanceProfile' in kwargs:
- iam_instance_profile = kwargs['iamInstanceProfile']
- if image_id is None and 'imageId' in kwargs:
- image_id = kwargs['imageId']
- if immediate_od_recover_threshold is None and 'immediateOdRecoverThreshold' in kwargs:
- immediate_od_recover_threshold = kwargs['immediateOdRecoverThreshold']
- if instance_types_ondemand is None and 'instanceTypesOndemand' in kwargs:
- instance_types_ondemand = kwargs['instanceTypesOndemand']
- if instance_types_preferred_spots is None and 'instanceTypesPreferredSpots' in kwargs:
- instance_types_preferred_spots = kwargs['instanceTypesPreferredSpots']
- if instance_types_spots is None and 'instanceTypesSpots' in kwargs:
- instance_types_spots = kwargs['instanceTypesSpots']
- if instance_types_weights is None and 'instanceTypesWeights' in kwargs:
- instance_types_weights = kwargs['instanceTypesWeights']
- if integration_beanstalk is None and 'integrationBeanstalk' in kwargs:
- integration_beanstalk = kwargs['integrationBeanstalk']
- if integration_codedeploy is None and 'integrationCodedeploy' in kwargs:
- integration_codedeploy = kwargs['integrationCodedeploy']
- if integration_docker_swarm is None and 'integrationDockerSwarm' in kwargs:
- integration_docker_swarm = kwargs['integrationDockerSwarm']
- if integration_ecs is None and 'integrationEcs' in kwargs:
- integration_ecs = kwargs['integrationEcs']
- if integration_gitlab is None and 'integrationGitlab' in kwargs:
- integration_gitlab = kwargs['integrationGitlab']
- if integration_kubernetes is None and 'integrationKubernetes' in kwargs:
- integration_kubernetes = kwargs['integrationKubernetes']
- if integration_mesosphere is None and 'integrationMesosphere' in kwargs:
- integration_mesosphere = kwargs['integrationMesosphere']
- if integration_multai_runtime is None and 'integrationMultaiRuntime' in kwargs:
- integration_multai_runtime = kwargs['integrationMultaiRuntime']
- if integration_nomad is None and 'integrationNomad' in kwargs:
- integration_nomad = kwargs['integrationNomad']
- if integration_rancher is None and 'integrationRancher' in kwargs:
- integration_rancher = kwargs['integrationRancher']
- if integration_route53 is None and 'integrationRoute53' in kwargs:
- integration_route53 = kwargs['integrationRoute53']
- if key_name is None and 'keyName' in kwargs:
- key_name = kwargs['keyName']
- if lifetime_period is None and 'lifetimePeriod' in kwargs:
- lifetime_period = kwargs['lifetimePeriod']
- if max_size is None and 'maxSize' in kwargs:
- max_size = kwargs['maxSize']
- if metadata_options is None and 'metadataOptions' in kwargs:
- metadata_options = kwargs['metadataOptions']
- if min_size is None and 'minSize' in kwargs:
- min_size = kwargs['minSize']
- if minimum_instance_lifetime is None and 'minimumInstanceLifetime' in kwargs:
- minimum_instance_lifetime = kwargs['minimumInstanceLifetime']
- if multai_target_sets is None and 'multaiTargetSets' in kwargs:
- multai_target_sets = kwargs['multaiTargetSets']
- if multiple_metrics is None and 'multipleMetrics' in kwargs:
- multiple_metrics = kwargs['multipleMetrics']
- if network_interfaces is None and 'networkInterfaces' in kwargs:
- network_interfaces = kwargs['networkInterfaces']
- if on_demand_types is None and 'onDemandTypes' in kwargs:
- on_demand_types = kwargs['onDemandTypes']
- if ondemand_count is None and 'ondemandCount' in kwargs:
- ondemand_count = kwargs['ondemandCount']
- if persist_block_devices is None and 'persistBlockDevices' in kwargs:
- persist_block_devices = kwargs['persistBlockDevices']
- if persist_private_ip is None and 'persistPrivateIp' in kwargs:
- persist_private_ip = kwargs['persistPrivateIp']
- if persist_root_device is None and 'persistRootDevice' in kwargs:
- persist_root_device = kwargs['persistRootDevice']
- if placement_tenancy is None and 'placementTenancy' in kwargs:
- placement_tenancy = kwargs['placementTenancy']
- if preferred_availability_zones is None and 'preferredAvailabilityZones' in kwargs:
- preferred_availability_zones = kwargs['preferredAvailabilityZones']
- if private_ips is None and 'privateIps' in kwargs:
- private_ips = kwargs['privateIps']
- if resource_requirements is None and 'resourceRequirements' in kwargs:
- resource_requirements = kwargs['resourceRequirements']
- if resource_tag_specifications is None and 'resourceTagSpecifications' in kwargs:
- resource_tag_specifications = kwargs['resourceTagSpecifications']
- if revert_to_spot is None and 'revertToSpot' in kwargs:
- revert_to_spot = kwargs['revertToSpot']
- if scaling_down_policies is None and 'scalingDownPolicies' in kwargs:
- scaling_down_policies = kwargs['scalingDownPolicies']
- if scaling_strategies is None and 'scalingStrategies' in kwargs:
- scaling_strategies = kwargs['scalingStrategies']
- if scaling_target_policies is None and 'scalingTargetPolicies' in kwargs:
- scaling_target_policies = kwargs['scalingTargetPolicies']
- if scaling_up_policies is None and 'scalingUpPolicies' in kwargs:
- scaling_up_policies = kwargs['scalingUpPolicies']
- if scheduled_tasks is None and 'scheduledTasks' in kwargs:
- scheduled_tasks = kwargs['scheduledTasks']
- if security_groups is None and 'securityGroups' in kwargs:
- security_groups = kwargs['securityGroups']
- if shutdown_script is None and 'shutdownScript' in kwargs:
- shutdown_script = kwargs['shutdownScript']
- if spot_percentage is None and 'spotPercentage' in kwargs:
- spot_percentage = kwargs['spotPercentage']
- if stateful_deallocation is None and 'statefulDeallocation' in kwargs:
- stateful_deallocation = kwargs['statefulDeallocation']
- if stateful_instance_actions is None and 'statefulInstanceActions' in kwargs:
- stateful_instance_actions = kwargs['statefulInstanceActions']
- if subnet_ids is None and 'subnetIds' in kwargs:
- subnet_ids = kwargs['subnetIds']
- if target_group_arns is None and 'targetGroupArns' in kwargs:
- target_group_arns = kwargs['targetGroupArns']
- if update_policy is None and 'updatePolicy' in kwargs:
- update_policy = kwargs['updatePolicy']
- if user_data is None and 'userData' in kwargs:
- user_data = kwargs['userData']
- if utilize_commitments is None and 'utilizeCommitments' in kwargs:
- utilize_commitments = kwargs['utilizeCommitments']
- if utilize_reserved_instances is None and 'utilizeReservedInstances' in kwargs:
- utilize_reserved_instances = kwargs['utilizeReservedInstances']
- if wait_for_capacity is None and 'waitForCapacity' in kwargs:
- wait_for_capacity = kwargs['waitForCapacity']
- if wait_for_capacity_timeout is None and 'waitForCapacityTimeout' in kwargs:
- wait_for_capacity_timeout = kwargs['waitForCapacityTimeout']
-
if availability_zones is not None:
- _setter("availability_zones", availability_zones)
+ pulumi.set(__self__, "availability_zones", availability_zones)
if block_devices_mode is not None:
- _setter("block_devices_mode", block_devices_mode)
+ pulumi.set(__self__, "block_devices_mode", block_devices_mode)
if capacity_unit is not None:
- _setter("capacity_unit", capacity_unit)
+ pulumi.set(__self__, "capacity_unit", capacity_unit)
if consider_od_pricing is not None:
- _setter("consider_od_pricing", consider_od_pricing)
+ pulumi.set(__self__, "consider_od_pricing", consider_od_pricing)
if cpu_credits is not None:
- _setter("cpu_credits", cpu_credits)
+ pulumi.set(__self__, "cpu_credits", cpu_credits)
if cpu_options is not None:
- _setter("cpu_options", cpu_options)
+ pulumi.set(__self__, "cpu_options", cpu_options)
if description is not None:
- _setter("description", description)
+ pulumi.set(__self__, "description", description)
if desired_capacity is not None:
- _setter("desired_capacity", desired_capacity)
+ pulumi.set(__self__, "desired_capacity", desired_capacity)
if draining_timeout is not None:
- _setter("draining_timeout", draining_timeout)
+ pulumi.set(__self__, "draining_timeout", draining_timeout)
if ebs_block_devices is not None:
- _setter("ebs_block_devices", ebs_block_devices)
+ pulumi.set(__self__, "ebs_block_devices", ebs_block_devices)
if ebs_optimized is not None:
- _setter("ebs_optimized", ebs_optimized)
+ pulumi.set(__self__, "ebs_optimized", ebs_optimized)
if elastic_ips is not None:
- _setter("elastic_ips", elastic_ips)
+ pulumi.set(__self__, "elastic_ips", elastic_ips)
if elastic_load_balancers is not None:
- _setter("elastic_load_balancers", elastic_load_balancers)
+ pulumi.set(__self__, "elastic_load_balancers", elastic_load_balancers)
if enable_monitoring is not None:
- _setter("enable_monitoring", enable_monitoring)
+ pulumi.set(__self__, "enable_monitoring", enable_monitoring)
if ephemeral_block_devices is not None:
- _setter("ephemeral_block_devices", ephemeral_block_devices)
+ pulumi.set(__self__, "ephemeral_block_devices", ephemeral_block_devices)
if fallback_to_ondemand is not None:
- _setter("fallback_to_ondemand", fallback_to_ondemand)
+ pulumi.set(__self__, "fallback_to_ondemand", fallback_to_ondemand)
if health_check_grace_period is not None:
- _setter("health_check_grace_period", health_check_grace_period)
+ pulumi.set(__self__, "health_check_grace_period", health_check_grace_period)
if health_check_type is not None:
- _setter("health_check_type", health_check_type)
+ pulumi.set(__self__, "health_check_type", health_check_type)
if health_check_unhealthy_duration_before_replacement is not None:
- _setter("health_check_unhealthy_duration_before_replacement", health_check_unhealthy_duration_before_replacement)
+ pulumi.set(__self__, "health_check_unhealthy_duration_before_replacement", health_check_unhealthy_duration_before_replacement)
if iam_instance_profile is not None:
- _setter("iam_instance_profile", iam_instance_profile)
+ pulumi.set(__self__, "iam_instance_profile", iam_instance_profile)
if image_id is not None:
- _setter("image_id", image_id)
+ pulumi.set(__self__, "image_id", image_id)
if images is not None:
- _setter("images", images)
+ pulumi.set(__self__, "images", images)
if immediate_od_recover_threshold is not None:
- _setter("immediate_od_recover_threshold", immediate_od_recover_threshold)
+ pulumi.set(__self__, "immediate_od_recover_threshold", immediate_od_recover_threshold)
if instance_types_ondemand is not None:
- _setter("instance_types_ondemand", instance_types_ondemand)
+ pulumi.set(__self__, "instance_types_ondemand", instance_types_ondemand)
if instance_types_preferred_spots is not None:
- _setter("instance_types_preferred_spots", instance_types_preferred_spots)
+ pulumi.set(__self__, "instance_types_preferred_spots", instance_types_preferred_spots)
if instance_types_spots is not None:
- _setter("instance_types_spots", instance_types_spots)
+ pulumi.set(__self__, "instance_types_spots", instance_types_spots)
if instance_types_weights is not None:
- _setter("instance_types_weights", instance_types_weights)
+ pulumi.set(__self__, "instance_types_weights", instance_types_weights)
if integration_beanstalk is not None:
- _setter("integration_beanstalk", integration_beanstalk)
+ pulumi.set(__self__, "integration_beanstalk", integration_beanstalk)
if integration_codedeploy is not None:
- _setter("integration_codedeploy", integration_codedeploy)
+ pulumi.set(__self__, "integration_codedeploy", integration_codedeploy)
if integration_docker_swarm is not None:
- _setter("integration_docker_swarm", integration_docker_swarm)
+ pulumi.set(__self__, "integration_docker_swarm", integration_docker_swarm)
if integration_ecs is not None:
- _setter("integration_ecs", integration_ecs)
+ pulumi.set(__self__, "integration_ecs", integration_ecs)
if integration_gitlab is not None:
- _setter("integration_gitlab", integration_gitlab)
+ pulumi.set(__self__, "integration_gitlab", integration_gitlab)
if integration_kubernetes is not None:
- _setter("integration_kubernetes", integration_kubernetes)
+ pulumi.set(__self__, "integration_kubernetes", integration_kubernetes)
if integration_mesosphere is not None:
- _setter("integration_mesosphere", integration_mesosphere)
+ pulumi.set(__self__, "integration_mesosphere", integration_mesosphere)
if integration_multai_runtime is not None:
- _setter("integration_multai_runtime", integration_multai_runtime)
+ pulumi.set(__self__, "integration_multai_runtime", integration_multai_runtime)
if integration_nomad is not None:
- _setter("integration_nomad", integration_nomad)
+ pulumi.set(__self__, "integration_nomad", integration_nomad)
if integration_rancher is not None:
- _setter("integration_rancher", integration_rancher)
+ pulumi.set(__self__, "integration_rancher", integration_rancher)
if integration_route53 is not None:
- _setter("integration_route53", integration_route53)
+ pulumi.set(__self__, "integration_route53", integration_route53)
if itfs is not None:
- _setter("itfs", itfs)
+ pulumi.set(__self__, "itfs", itfs)
if key_name is not None:
- _setter("key_name", key_name)
+ pulumi.set(__self__, "key_name", key_name)
if lifetime_period is not None:
- _setter("lifetime_period", lifetime_period)
+ pulumi.set(__self__, "lifetime_period", lifetime_period)
if max_size is not None:
- _setter("max_size", max_size)
+ pulumi.set(__self__, "max_size", max_size)
if metadata_options is not None:
- _setter("metadata_options", metadata_options)
+ pulumi.set(__self__, "metadata_options", metadata_options)
if min_size is not None:
- _setter("min_size", min_size)
+ pulumi.set(__self__, "min_size", min_size)
if minimum_instance_lifetime is not None:
- _setter("minimum_instance_lifetime", minimum_instance_lifetime)
+ pulumi.set(__self__, "minimum_instance_lifetime", minimum_instance_lifetime)
if multai_target_sets is not None:
- _setter("multai_target_sets", multai_target_sets)
+ pulumi.set(__self__, "multai_target_sets", multai_target_sets)
if multiple_metrics is not None:
- _setter("multiple_metrics", multiple_metrics)
+ pulumi.set(__self__, "multiple_metrics", multiple_metrics)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if network_interfaces is not None:
- _setter("network_interfaces", network_interfaces)
+ pulumi.set(__self__, "network_interfaces", network_interfaces)
if on_demand_types is not None:
- _setter("on_demand_types", on_demand_types)
+ pulumi.set(__self__, "on_demand_types", on_demand_types)
if ondemand_count is not None:
- _setter("ondemand_count", ondemand_count)
+ pulumi.set(__self__, "ondemand_count", ondemand_count)
if orientation is not None:
- _setter("orientation", orientation)
+ pulumi.set(__self__, "orientation", orientation)
if persist_block_devices is not None:
- _setter("persist_block_devices", persist_block_devices)
+ pulumi.set(__self__, "persist_block_devices", persist_block_devices)
if persist_private_ip is not None:
- _setter("persist_private_ip", persist_private_ip)
+ pulumi.set(__self__, "persist_private_ip", persist_private_ip)
if persist_root_device is not None:
- _setter("persist_root_device", persist_root_device)
+ pulumi.set(__self__, "persist_root_device", persist_root_device)
if placement_tenancy is not None:
- _setter("placement_tenancy", placement_tenancy)
+ pulumi.set(__self__, "placement_tenancy", placement_tenancy)
if preferred_availability_zones is not None:
- _setter("preferred_availability_zones", preferred_availability_zones)
+ pulumi.set(__self__, "preferred_availability_zones", preferred_availability_zones)
if private_ips is not None:
- _setter("private_ips", private_ips)
+ pulumi.set(__self__, "private_ips", private_ips)
if product is not None:
- _setter("product", product)
+ pulumi.set(__self__, "product", product)
if region is not None:
- _setter("region", region)
+ pulumi.set(__self__, "region", region)
if resource_requirements is not None:
- _setter("resource_requirements", resource_requirements)
+ pulumi.set(__self__, "resource_requirements", resource_requirements)
if resource_tag_specifications is not None:
- _setter("resource_tag_specifications", resource_tag_specifications)
+ pulumi.set(__self__, "resource_tag_specifications", resource_tag_specifications)
if revert_to_spot is not None:
- _setter("revert_to_spot", revert_to_spot)
+ pulumi.set(__self__, "revert_to_spot", revert_to_spot)
if scaling_down_policies is not None:
- _setter("scaling_down_policies", scaling_down_policies)
+ pulumi.set(__self__, "scaling_down_policies", scaling_down_policies)
if scaling_strategies is not None:
- _setter("scaling_strategies", scaling_strategies)
+ pulumi.set(__self__, "scaling_strategies", scaling_strategies)
if scaling_target_policies is not None:
- _setter("scaling_target_policies", scaling_target_policies)
+ pulumi.set(__self__, "scaling_target_policies", scaling_target_policies)
if scaling_up_policies is not None:
- _setter("scaling_up_policies", scaling_up_policies)
+ pulumi.set(__self__, "scaling_up_policies", scaling_up_policies)
if scheduled_tasks is not None:
- _setter("scheduled_tasks", scheduled_tasks)
+ pulumi.set(__self__, "scheduled_tasks", scheduled_tasks)
if security_groups is not None:
- _setter("security_groups", security_groups)
+ pulumi.set(__self__, "security_groups", security_groups)
if shutdown_script is not None:
- _setter("shutdown_script", shutdown_script)
+ pulumi.set(__self__, "shutdown_script", shutdown_script)
if signals is not None:
- _setter("signals", signals)
+ pulumi.set(__self__, "signals", signals)
if spot_percentage is not None:
- _setter("spot_percentage", spot_percentage)
+ pulumi.set(__self__, "spot_percentage", spot_percentage)
if stateful_deallocation is not None:
- _setter("stateful_deallocation", stateful_deallocation)
+ pulumi.set(__self__, "stateful_deallocation", stateful_deallocation)
if stateful_instance_actions is not None:
- _setter("stateful_instance_actions", stateful_instance_actions)
+ pulumi.set(__self__, "stateful_instance_actions", stateful_instance_actions)
if subnet_ids is not None:
- _setter("subnet_ids", subnet_ids)
+ pulumi.set(__self__, "subnet_ids", subnet_ids)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
if target_group_arns is not None:
- _setter("target_group_arns", target_group_arns)
+ pulumi.set(__self__, "target_group_arns", target_group_arns)
if update_policy is not None:
- _setter("update_policy", update_policy)
+ pulumi.set(__self__, "update_policy", update_policy)
if user_data is not None:
- _setter("user_data", user_data)
+ pulumi.set(__self__, "user_data", user_data)
if utilize_commitments is not None:
- _setter("utilize_commitments", utilize_commitments)
+ pulumi.set(__self__, "utilize_commitments", utilize_commitments)
if utilize_reserved_instances is not None:
- _setter("utilize_reserved_instances", utilize_reserved_instances)
+ pulumi.set(__self__, "utilize_reserved_instances", utilize_reserved_instances)
if wait_for_capacity is not None:
- _setter("wait_for_capacity", wait_for_capacity)
+ pulumi.set(__self__, "wait_for_capacity", wait_for_capacity)
if wait_for_capacity_timeout is not None:
- _setter("wait_for_capacity_timeout", wait_for_capacity_timeout)
+ pulumi.set(__self__, "wait_for_capacity_timeout", wait_for_capacity_timeout)
@property
@pulumi.getter(name="availabilityZones")
@@ -3435,10 +2781,6 @@ def __init__(__self__, resource_name: str, *args, **kwargs):
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
- kwargs = kwargs or {}
- def _setter(key, value):
- kwargs[key] = value
- ElastigroupArgs._configure(_setter, **kwargs)
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
@@ -3541,7 +2883,6 @@ def _internal_init(__self__,
__props__.__dict__["capacity_unit"] = capacity_unit
__props__.__dict__["consider_od_pricing"] = consider_od_pricing
__props__.__dict__["cpu_credits"] = cpu_credits
- cpu_options = _utilities.configure(cpu_options, ElastigroupCpuOptionsArgs, True)
__props__.__dict__["cpu_options"] = cpu_options
__props__.__dict__["description"] = description
__props__.__dict__["desired_capacity"] = desired_capacity
@@ -3566,38 +2907,25 @@ def _internal_init(__self__,
__props__.__dict__["instance_types_preferred_spots"] = instance_types_preferred_spots
__props__.__dict__["instance_types_spots"] = instance_types_spots
__props__.__dict__["instance_types_weights"] = instance_types_weights
- integration_beanstalk = _utilities.configure(integration_beanstalk, ElastigroupIntegrationBeanstalkArgs, True)
__props__.__dict__["integration_beanstalk"] = integration_beanstalk
- integration_codedeploy = _utilities.configure(integration_codedeploy, ElastigroupIntegrationCodedeployArgs, True)
__props__.__dict__["integration_codedeploy"] = integration_codedeploy
- integration_docker_swarm = _utilities.configure(integration_docker_swarm, ElastigroupIntegrationDockerSwarmArgs, True)
__props__.__dict__["integration_docker_swarm"] = integration_docker_swarm
- integration_ecs = _utilities.configure(integration_ecs, ElastigroupIntegrationEcsArgs, True)
__props__.__dict__["integration_ecs"] = integration_ecs
- integration_gitlab = _utilities.configure(integration_gitlab, ElastigroupIntegrationGitlabArgs, True)
__props__.__dict__["integration_gitlab"] = integration_gitlab
- integration_kubernetes = _utilities.configure(integration_kubernetes, ElastigroupIntegrationKubernetesArgs, True)
__props__.__dict__["integration_kubernetes"] = integration_kubernetes
- integration_mesosphere = _utilities.configure(integration_mesosphere, ElastigroupIntegrationMesosphereArgs, True)
__props__.__dict__["integration_mesosphere"] = integration_mesosphere
- integration_multai_runtime = _utilities.configure(integration_multai_runtime, ElastigroupIntegrationMultaiRuntimeArgs, True)
__props__.__dict__["integration_multai_runtime"] = integration_multai_runtime
- integration_nomad = _utilities.configure(integration_nomad, ElastigroupIntegrationNomadArgs, True)
__props__.__dict__["integration_nomad"] = integration_nomad
- integration_rancher = _utilities.configure(integration_rancher, ElastigroupIntegrationRancherArgs, True)
__props__.__dict__["integration_rancher"] = integration_rancher
- integration_route53 = _utilities.configure(integration_route53, ElastigroupIntegrationRoute53Args, True)
__props__.__dict__["integration_route53"] = integration_route53
__props__.__dict__["itfs"] = itfs
__props__.__dict__["key_name"] = key_name
__props__.__dict__["lifetime_period"] = lifetime_period
__props__.__dict__["max_size"] = max_size
- metadata_options = _utilities.configure(metadata_options, ElastigroupMetadataOptionsArgs, True)
__props__.__dict__["metadata_options"] = metadata_options
__props__.__dict__["min_size"] = min_size
__props__.__dict__["minimum_instance_lifetime"] = minimum_instance_lifetime
__props__.__dict__["multai_target_sets"] = multai_target_sets
- multiple_metrics = _utilities.configure(multiple_metrics, ElastigroupMultipleMetricsArgs, True)
__props__.__dict__["multiple_metrics"] = multiple_metrics
__props__.__dict__["name"] = name
__props__.__dict__["network_interfaces"] = network_interfaces
@@ -3618,7 +2946,6 @@ def _internal_init(__self__,
__props__.__dict__["region"] = region
__props__.__dict__["resource_requirements"] = resource_requirements
__props__.__dict__["resource_tag_specifications"] = resource_tag_specifications
- revert_to_spot = _utilities.configure(revert_to_spot, ElastigroupRevertToSpotArgs, True)
__props__.__dict__["revert_to_spot"] = revert_to_spot
__props__.__dict__["scaling_down_policies"] = scaling_down_policies
__props__.__dict__["scaling_strategies"] = scaling_strategies
@@ -3631,13 +2958,11 @@ def _internal_init(__self__,
__props__.__dict__["shutdown_script"] = shutdown_script
__props__.__dict__["signals"] = signals
__props__.__dict__["spot_percentage"] = spot_percentage
- stateful_deallocation = _utilities.configure(stateful_deallocation, ElastigroupStatefulDeallocationArgs, True)
__props__.__dict__["stateful_deallocation"] = stateful_deallocation
__props__.__dict__["stateful_instance_actions"] = stateful_instance_actions
__props__.__dict__["subnet_ids"] = subnet_ids
__props__.__dict__["tags"] = tags
__props__.__dict__["target_group_arns"] = target_group_arns
- update_policy = _utilities.configure(update_policy, ElastigroupUpdatePolicyArgs, True)
__props__.__dict__["update_policy"] = update_policy
__props__.__dict__["user_data"] = user_data
__props__.__dict__["utilize_commitments"] = utilize_commitments
diff --git a/sdk/python/pulumi_spotinst/aws/managed_instance.py b/sdk/python/pulumi_spotinst/aws/managed_instance.py
index 47fe0ccf..58fa30d8 100644
--- a/sdk/python/pulumi_spotinst/aws/managed_instance.py
+++ b/sdk/python/pulumi_spotinst/aws/managed_instance.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs
from ._inputs import *
@@ -64,277 +64,90 @@ def __init__(__self__, *,
"""
The set of arguments for constructing a ManagedInstance resource.
"""
- ManagedInstanceArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- image_id=image_id,
- instance_types=instance_types,
- persist_block_devices=persist_block_devices,
- product=product,
- subnet_ids=subnet_ids,
- vpc_id=vpc_id,
- auto_healing=auto_healing,
- block_device_mappings=block_device_mappings,
- block_devices_mode=block_devices_mode,
- cpu_credits=cpu_credits,
- deletes=deletes,
- description=description,
- draining_timeout=draining_timeout,
- ebs_optimized=ebs_optimized,
- elastic_ip=elastic_ip,
- enable_monitoring=enable_monitoring,
- fall_back_to_od=fall_back_to_od,
- grace_period=grace_period,
- health_check_type=health_check_type,
- iam_instance_profile=iam_instance_profile,
- integration_route53=integration_route53,
- key_pair=key_pair,
- life_cycle=life_cycle,
- load_balancers=load_balancers,
- managed_instance_action=managed_instance_action,
- minimum_instance_lifetime=minimum_instance_lifetime,
- name=name,
- network_interfaces=network_interfaces,
- optimization_windows=optimization_windows,
- orientation=orientation,
- persist_private_ip=persist_private_ip,
- persist_root_device=persist_root_device,
- placement_tenancy=placement_tenancy,
- preferred_type=preferred_type,
- private_ip=private_ip,
- region=region,
- resource_tag_specifications=resource_tag_specifications,
- revert_to_spot=revert_to_spot,
- scheduled_tasks=scheduled_tasks,
- security_group_ids=security_group_ids,
- shutdown_script=shutdown_script,
- tags=tags,
- unhealthy_duration=unhealthy_duration,
- user_data=user_data,
- utilize_reserved_instances=utilize_reserved_instances,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- image_id: Optional[pulumi.Input[str]] = None,
- instance_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- persist_block_devices: Optional[pulumi.Input[bool]] = None,
- product: Optional[pulumi.Input[str]] = None,
- subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- vpc_id: Optional[pulumi.Input[str]] = None,
- auto_healing: Optional[pulumi.Input[bool]] = None,
- block_device_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['ManagedInstanceBlockDeviceMappingArgs']]]] = None,
- block_devices_mode: Optional[pulumi.Input[str]] = None,
- cpu_credits: Optional[pulumi.Input[str]] = None,
- deletes: Optional[pulumi.Input[Sequence[pulumi.Input['ManagedInstanceDeleteArgs']]]] = None,
- description: Optional[pulumi.Input[str]] = None,
- draining_timeout: Optional[pulumi.Input[int]] = None,
- ebs_optimized: Optional[pulumi.Input[bool]] = None,
- elastic_ip: Optional[pulumi.Input[str]] = None,
- enable_monitoring: Optional[pulumi.Input[bool]] = None,
- fall_back_to_od: Optional[pulumi.Input[bool]] = None,
- grace_period: Optional[pulumi.Input[int]] = None,
- health_check_type: Optional[pulumi.Input[str]] = None,
- iam_instance_profile: Optional[pulumi.Input[str]] = None,
- integration_route53: Optional[pulumi.Input['ManagedInstanceIntegrationRoute53Args']] = None,
- key_pair: Optional[pulumi.Input[str]] = None,
- life_cycle: Optional[pulumi.Input[str]] = None,
- load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input['ManagedInstanceLoadBalancerArgs']]]] = None,
- managed_instance_action: Optional[pulumi.Input['ManagedInstanceManagedInstanceActionArgs']] = None,
- minimum_instance_lifetime: Optional[pulumi.Input[int]] = None,
- name: Optional[pulumi.Input[str]] = None,
- network_interfaces: Optional[pulumi.Input[Sequence[pulumi.Input['ManagedInstanceNetworkInterfaceArgs']]]] = None,
- optimization_windows: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- orientation: Optional[pulumi.Input[str]] = None,
- persist_private_ip: Optional[pulumi.Input[bool]] = None,
- persist_root_device: Optional[pulumi.Input[bool]] = None,
- placement_tenancy: Optional[pulumi.Input[str]] = None,
- preferred_type: Optional[pulumi.Input[str]] = None,
- private_ip: Optional[pulumi.Input[str]] = None,
- region: Optional[pulumi.Input[str]] = None,
- resource_tag_specifications: Optional[pulumi.Input[Sequence[pulumi.Input['ManagedInstanceResourceTagSpecificationArgs']]]] = None,
- revert_to_spot: Optional[pulumi.Input['ManagedInstanceRevertToSpotArgs']] = None,
- scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['ManagedInstanceScheduledTaskArgs']]]] = None,
- security_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- shutdown_script: Optional[pulumi.Input[str]] = None,
- tags: Optional[pulumi.Input[Sequence[pulumi.Input['ManagedInstanceTagArgs']]]] = None,
- unhealthy_duration: Optional[pulumi.Input[int]] = None,
- user_data: Optional[pulumi.Input[str]] = None,
- utilize_reserved_instances: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if image_id is None and 'imageId' in kwargs:
- image_id = kwargs['imageId']
- if image_id is None:
- raise TypeError("Missing 'image_id' argument")
- if instance_types is None and 'instanceTypes' in kwargs:
- instance_types = kwargs['instanceTypes']
- if instance_types is None:
- raise TypeError("Missing 'instance_types' argument")
- if persist_block_devices is None and 'persistBlockDevices' in kwargs:
- persist_block_devices = kwargs['persistBlockDevices']
- if persist_block_devices is None:
- raise TypeError("Missing 'persist_block_devices' argument")
- if product is None:
- raise TypeError("Missing 'product' argument")
- if subnet_ids is None and 'subnetIds' in kwargs:
- subnet_ids = kwargs['subnetIds']
- if subnet_ids is None:
- raise TypeError("Missing 'subnet_ids' argument")
- if vpc_id is None and 'vpcId' in kwargs:
- vpc_id = kwargs['vpcId']
- if vpc_id is None:
- raise TypeError("Missing 'vpc_id' argument")
- if auto_healing is None and 'autoHealing' in kwargs:
- auto_healing = kwargs['autoHealing']
- if block_device_mappings is None and 'blockDeviceMappings' in kwargs:
- block_device_mappings = kwargs['blockDeviceMappings']
- if block_devices_mode is None and 'blockDevicesMode' in kwargs:
- block_devices_mode = kwargs['blockDevicesMode']
- if cpu_credits is None and 'cpuCredits' in kwargs:
- cpu_credits = kwargs['cpuCredits']
- if draining_timeout is None and 'drainingTimeout' in kwargs:
- draining_timeout = kwargs['drainingTimeout']
- if ebs_optimized is None and 'ebsOptimized' in kwargs:
- ebs_optimized = kwargs['ebsOptimized']
- if elastic_ip is None and 'elasticIp' in kwargs:
- elastic_ip = kwargs['elasticIp']
- if enable_monitoring is None and 'enableMonitoring' in kwargs:
- enable_monitoring = kwargs['enableMonitoring']
- if fall_back_to_od is None and 'fallBackToOd' in kwargs:
- fall_back_to_od = kwargs['fallBackToOd']
- if grace_period is None and 'gracePeriod' in kwargs:
- grace_period = kwargs['gracePeriod']
- if health_check_type is None and 'healthCheckType' in kwargs:
- health_check_type = kwargs['healthCheckType']
- if iam_instance_profile is None and 'iamInstanceProfile' in kwargs:
- iam_instance_profile = kwargs['iamInstanceProfile']
- if integration_route53 is None and 'integrationRoute53' in kwargs:
- integration_route53 = kwargs['integrationRoute53']
- if key_pair is None and 'keyPair' in kwargs:
- key_pair = kwargs['keyPair']
- if life_cycle is None and 'lifeCycle' in kwargs:
- life_cycle = kwargs['lifeCycle']
- if load_balancers is None and 'loadBalancers' in kwargs:
- load_balancers = kwargs['loadBalancers']
- if managed_instance_action is None and 'managedInstanceAction' in kwargs:
- managed_instance_action = kwargs['managedInstanceAction']
- if minimum_instance_lifetime is None and 'minimumInstanceLifetime' in kwargs:
- minimum_instance_lifetime = kwargs['minimumInstanceLifetime']
- if network_interfaces is None and 'networkInterfaces' in kwargs:
- network_interfaces = kwargs['networkInterfaces']
- if optimization_windows is None and 'optimizationWindows' in kwargs:
- optimization_windows = kwargs['optimizationWindows']
- if persist_private_ip is None and 'persistPrivateIp' in kwargs:
- persist_private_ip = kwargs['persistPrivateIp']
- if persist_root_device is None and 'persistRootDevice' in kwargs:
- persist_root_device = kwargs['persistRootDevice']
- if placement_tenancy is None and 'placementTenancy' in kwargs:
- placement_tenancy = kwargs['placementTenancy']
- if preferred_type is None and 'preferredType' in kwargs:
- preferred_type = kwargs['preferredType']
- if private_ip is None and 'privateIp' in kwargs:
- private_ip = kwargs['privateIp']
- if resource_tag_specifications is None and 'resourceTagSpecifications' in kwargs:
- resource_tag_specifications = kwargs['resourceTagSpecifications']
- if revert_to_spot is None and 'revertToSpot' in kwargs:
- revert_to_spot = kwargs['revertToSpot']
- if scheduled_tasks is None and 'scheduledTasks' in kwargs:
- scheduled_tasks = kwargs['scheduledTasks']
- if security_group_ids is None and 'securityGroupIds' in kwargs:
- security_group_ids = kwargs['securityGroupIds']
- if shutdown_script is None and 'shutdownScript' in kwargs:
- shutdown_script = kwargs['shutdownScript']
- if unhealthy_duration is None and 'unhealthyDuration' in kwargs:
- unhealthy_duration = kwargs['unhealthyDuration']
- if user_data is None and 'userData' in kwargs:
- user_data = kwargs['userData']
- if utilize_reserved_instances is None and 'utilizeReservedInstances' in kwargs:
- utilize_reserved_instances = kwargs['utilizeReservedInstances']
-
- _setter("image_id", image_id)
- _setter("instance_types", instance_types)
- _setter("persist_block_devices", persist_block_devices)
- _setter("product", product)
- _setter("subnet_ids", subnet_ids)
- _setter("vpc_id", vpc_id)
+ pulumi.set(__self__, "image_id", image_id)
+ pulumi.set(__self__, "instance_types", instance_types)
+ pulumi.set(__self__, "persist_block_devices", persist_block_devices)
+ pulumi.set(__self__, "product", product)
+ pulumi.set(__self__, "subnet_ids", subnet_ids)
+ pulumi.set(__self__, "vpc_id", vpc_id)
if auto_healing is not None:
- _setter("auto_healing", auto_healing)
+ pulumi.set(__self__, "auto_healing", auto_healing)
if block_device_mappings is not None:
- _setter("block_device_mappings", block_device_mappings)
+ pulumi.set(__self__, "block_device_mappings", block_device_mappings)
if block_devices_mode is not None:
- _setter("block_devices_mode", block_devices_mode)
+ pulumi.set(__self__, "block_devices_mode", block_devices_mode)
if cpu_credits is not None:
- _setter("cpu_credits", cpu_credits)
+ pulumi.set(__self__, "cpu_credits", cpu_credits)
if deletes is not None:
- _setter("deletes", deletes)
+ pulumi.set(__self__, "deletes", deletes)
if description is not None:
- _setter("description", description)
+ pulumi.set(__self__, "description", description)
if draining_timeout is not None:
- _setter("draining_timeout", draining_timeout)
+ pulumi.set(__self__, "draining_timeout", draining_timeout)
if ebs_optimized is not None:
- _setter("ebs_optimized", ebs_optimized)
+ pulumi.set(__self__, "ebs_optimized", ebs_optimized)
if elastic_ip is not None:
- _setter("elastic_ip", elastic_ip)
+ pulumi.set(__self__, "elastic_ip", elastic_ip)
if enable_monitoring is not None:
- _setter("enable_monitoring", enable_monitoring)
+ pulumi.set(__self__, "enable_monitoring", enable_monitoring)
if fall_back_to_od is not None:
- _setter("fall_back_to_od", fall_back_to_od)
+ pulumi.set(__self__, "fall_back_to_od", fall_back_to_od)
if grace_period is not None:
- _setter("grace_period", grace_period)
+ pulumi.set(__self__, "grace_period", grace_period)
if health_check_type is not None:
- _setter("health_check_type", health_check_type)
+ pulumi.set(__self__, "health_check_type", health_check_type)
if iam_instance_profile is not None:
- _setter("iam_instance_profile", iam_instance_profile)
+ pulumi.set(__self__, "iam_instance_profile", iam_instance_profile)
if integration_route53 is not None:
- _setter("integration_route53", integration_route53)
+ pulumi.set(__self__, "integration_route53", integration_route53)
if key_pair is not None:
- _setter("key_pair", key_pair)
+ pulumi.set(__self__, "key_pair", key_pair)
if life_cycle is not None:
- _setter("life_cycle", life_cycle)
+ pulumi.set(__self__, "life_cycle", life_cycle)
if load_balancers is not None:
- _setter("load_balancers", load_balancers)
+ pulumi.set(__self__, "load_balancers", load_balancers)
if managed_instance_action is not None:
- _setter("managed_instance_action", managed_instance_action)
+ pulumi.set(__self__, "managed_instance_action", managed_instance_action)
if minimum_instance_lifetime is not None:
- _setter("minimum_instance_lifetime", minimum_instance_lifetime)
+ pulumi.set(__self__, "minimum_instance_lifetime", minimum_instance_lifetime)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if network_interfaces is not None:
- _setter("network_interfaces", network_interfaces)
+ pulumi.set(__self__, "network_interfaces", network_interfaces)
if optimization_windows is not None:
- _setter("optimization_windows", optimization_windows)
+ pulumi.set(__self__, "optimization_windows", optimization_windows)
if orientation is not None:
- _setter("orientation", orientation)
+ pulumi.set(__self__, "orientation", orientation)
if persist_private_ip is not None:
- _setter("persist_private_ip", persist_private_ip)
+ pulumi.set(__self__, "persist_private_ip", persist_private_ip)
if persist_root_device is not None:
- _setter("persist_root_device", persist_root_device)
+ pulumi.set(__self__, "persist_root_device", persist_root_device)
if placement_tenancy is not None:
- _setter("placement_tenancy", placement_tenancy)
+ pulumi.set(__self__, "placement_tenancy", placement_tenancy)
if preferred_type is not None:
- _setter("preferred_type", preferred_type)
+ pulumi.set(__self__, "preferred_type", preferred_type)
if private_ip is not None:
- _setter("private_ip", private_ip)
+ pulumi.set(__self__, "private_ip", private_ip)
if region is not None:
- _setter("region", region)
+ pulumi.set(__self__, "region", region)
if resource_tag_specifications is not None:
- _setter("resource_tag_specifications", resource_tag_specifications)
+ pulumi.set(__self__, "resource_tag_specifications", resource_tag_specifications)
if revert_to_spot is not None:
- _setter("revert_to_spot", revert_to_spot)
+ pulumi.set(__self__, "revert_to_spot", revert_to_spot)
if scheduled_tasks is not None:
- _setter("scheduled_tasks", scheduled_tasks)
+ pulumi.set(__self__, "scheduled_tasks", scheduled_tasks)
if security_group_ids is not None:
- _setter("security_group_ids", security_group_ids)
+ pulumi.set(__self__, "security_group_ids", security_group_ids)
if shutdown_script is not None:
- _setter("shutdown_script", shutdown_script)
+ pulumi.set(__self__, "shutdown_script", shutdown_script)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
if unhealthy_duration is not None:
- _setter("unhealthy_duration", unhealthy_duration)
+ pulumi.set(__self__, "unhealthy_duration", unhealthy_duration)
if user_data is not None:
- _setter("user_data", user_data)
+ pulumi.set(__self__, "user_data", user_data)
if utilize_reserved_instances is not None:
- _setter("utilize_reserved_instances", utilize_reserved_instances)
+ pulumi.set(__self__, "utilize_reserved_instances", utilize_reserved_instances)
@property
@pulumi.getter(name="imageId")
@@ -793,271 +606,96 @@ def __init__(__self__, *,
"""
Input properties used for looking up and filtering ManagedInstance resources.
"""
- _ManagedInstanceState._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- auto_healing=auto_healing,
- block_device_mappings=block_device_mappings,
- block_devices_mode=block_devices_mode,
- cpu_credits=cpu_credits,
- deletes=deletes,
- description=description,
- draining_timeout=draining_timeout,
- ebs_optimized=ebs_optimized,
- elastic_ip=elastic_ip,
- enable_monitoring=enable_monitoring,
- fall_back_to_od=fall_back_to_od,
- grace_period=grace_period,
- health_check_type=health_check_type,
- iam_instance_profile=iam_instance_profile,
- image_id=image_id,
- instance_types=instance_types,
- integration_route53=integration_route53,
- key_pair=key_pair,
- life_cycle=life_cycle,
- load_balancers=load_balancers,
- managed_instance_action=managed_instance_action,
- minimum_instance_lifetime=minimum_instance_lifetime,
- name=name,
- network_interfaces=network_interfaces,
- optimization_windows=optimization_windows,
- orientation=orientation,
- persist_block_devices=persist_block_devices,
- persist_private_ip=persist_private_ip,
- persist_root_device=persist_root_device,
- placement_tenancy=placement_tenancy,
- preferred_type=preferred_type,
- private_ip=private_ip,
- product=product,
- region=region,
- resource_tag_specifications=resource_tag_specifications,
- revert_to_spot=revert_to_spot,
- scheduled_tasks=scheduled_tasks,
- security_group_ids=security_group_ids,
- shutdown_script=shutdown_script,
- subnet_ids=subnet_ids,
- tags=tags,
- unhealthy_duration=unhealthy_duration,
- user_data=user_data,
- utilize_reserved_instances=utilize_reserved_instances,
- vpc_id=vpc_id,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- auto_healing: Optional[pulumi.Input[bool]] = None,
- block_device_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['ManagedInstanceBlockDeviceMappingArgs']]]] = None,
- block_devices_mode: Optional[pulumi.Input[str]] = None,
- cpu_credits: Optional[pulumi.Input[str]] = None,
- deletes: Optional[pulumi.Input[Sequence[pulumi.Input['ManagedInstanceDeleteArgs']]]] = None,
- description: Optional[pulumi.Input[str]] = None,
- draining_timeout: Optional[pulumi.Input[int]] = None,
- ebs_optimized: Optional[pulumi.Input[bool]] = None,
- elastic_ip: Optional[pulumi.Input[str]] = None,
- enable_monitoring: Optional[pulumi.Input[bool]] = None,
- fall_back_to_od: Optional[pulumi.Input[bool]] = None,
- grace_period: Optional[pulumi.Input[int]] = None,
- health_check_type: Optional[pulumi.Input[str]] = None,
- iam_instance_profile: Optional[pulumi.Input[str]] = None,
- image_id: Optional[pulumi.Input[str]] = None,
- instance_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- integration_route53: Optional[pulumi.Input['ManagedInstanceIntegrationRoute53Args']] = None,
- key_pair: Optional[pulumi.Input[str]] = None,
- life_cycle: Optional[pulumi.Input[str]] = None,
- load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input['ManagedInstanceLoadBalancerArgs']]]] = None,
- managed_instance_action: Optional[pulumi.Input['ManagedInstanceManagedInstanceActionArgs']] = None,
- minimum_instance_lifetime: Optional[pulumi.Input[int]] = None,
- name: Optional[pulumi.Input[str]] = None,
- network_interfaces: Optional[pulumi.Input[Sequence[pulumi.Input['ManagedInstanceNetworkInterfaceArgs']]]] = None,
- optimization_windows: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- orientation: Optional[pulumi.Input[str]] = None,
- persist_block_devices: Optional[pulumi.Input[bool]] = None,
- persist_private_ip: Optional[pulumi.Input[bool]] = None,
- persist_root_device: Optional[pulumi.Input[bool]] = None,
- placement_tenancy: Optional[pulumi.Input[str]] = None,
- preferred_type: Optional[pulumi.Input[str]] = None,
- private_ip: Optional[pulumi.Input[str]] = None,
- product: Optional[pulumi.Input[str]] = None,
- region: Optional[pulumi.Input[str]] = None,
- resource_tag_specifications: Optional[pulumi.Input[Sequence[pulumi.Input['ManagedInstanceResourceTagSpecificationArgs']]]] = None,
- revert_to_spot: Optional[pulumi.Input['ManagedInstanceRevertToSpotArgs']] = None,
- scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['ManagedInstanceScheduledTaskArgs']]]] = None,
- security_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- shutdown_script: Optional[pulumi.Input[str]] = None,
- subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- tags: Optional[pulumi.Input[Sequence[pulumi.Input['ManagedInstanceTagArgs']]]] = None,
- unhealthy_duration: Optional[pulumi.Input[int]] = None,
- user_data: Optional[pulumi.Input[str]] = None,
- utilize_reserved_instances: Optional[pulumi.Input[bool]] = None,
- vpc_id: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if auto_healing is None and 'autoHealing' in kwargs:
- auto_healing = kwargs['autoHealing']
- if block_device_mappings is None and 'blockDeviceMappings' in kwargs:
- block_device_mappings = kwargs['blockDeviceMappings']
- if block_devices_mode is None and 'blockDevicesMode' in kwargs:
- block_devices_mode = kwargs['blockDevicesMode']
- if cpu_credits is None and 'cpuCredits' in kwargs:
- cpu_credits = kwargs['cpuCredits']
- if draining_timeout is None and 'drainingTimeout' in kwargs:
- draining_timeout = kwargs['drainingTimeout']
- if ebs_optimized is None and 'ebsOptimized' in kwargs:
- ebs_optimized = kwargs['ebsOptimized']
- if elastic_ip is None and 'elasticIp' in kwargs:
- elastic_ip = kwargs['elasticIp']
- if enable_monitoring is None and 'enableMonitoring' in kwargs:
- enable_monitoring = kwargs['enableMonitoring']
- if fall_back_to_od is None and 'fallBackToOd' in kwargs:
- fall_back_to_od = kwargs['fallBackToOd']
- if grace_period is None and 'gracePeriod' in kwargs:
- grace_period = kwargs['gracePeriod']
- if health_check_type is None and 'healthCheckType' in kwargs:
- health_check_type = kwargs['healthCheckType']
- if iam_instance_profile is None and 'iamInstanceProfile' in kwargs:
- iam_instance_profile = kwargs['iamInstanceProfile']
- if image_id is None and 'imageId' in kwargs:
- image_id = kwargs['imageId']
- if instance_types is None and 'instanceTypes' in kwargs:
- instance_types = kwargs['instanceTypes']
- if integration_route53 is None and 'integrationRoute53' in kwargs:
- integration_route53 = kwargs['integrationRoute53']
- if key_pair is None and 'keyPair' in kwargs:
- key_pair = kwargs['keyPair']
- if life_cycle is None and 'lifeCycle' in kwargs:
- life_cycle = kwargs['lifeCycle']
- if load_balancers is None and 'loadBalancers' in kwargs:
- load_balancers = kwargs['loadBalancers']
- if managed_instance_action is None and 'managedInstanceAction' in kwargs:
- managed_instance_action = kwargs['managedInstanceAction']
- if minimum_instance_lifetime is None and 'minimumInstanceLifetime' in kwargs:
- minimum_instance_lifetime = kwargs['minimumInstanceLifetime']
- if network_interfaces is None and 'networkInterfaces' in kwargs:
- network_interfaces = kwargs['networkInterfaces']
- if optimization_windows is None and 'optimizationWindows' in kwargs:
- optimization_windows = kwargs['optimizationWindows']
- if persist_block_devices is None and 'persistBlockDevices' in kwargs:
- persist_block_devices = kwargs['persistBlockDevices']
- if persist_private_ip is None and 'persistPrivateIp' in kwargs:
- persist_private_ip = kwargs['persistPrivateIp']
- if persist_root_device is None and 'persistRootDevice' in kwargs:
- persist_root_device = kwargs['persistRootDevice']
- if placement_tenancy is None and 'placementTenancy' in kwargs:
- placement_tenancy = kwargs['placementTenancy']
- if preferred_type is None and 'preferredType' in kwargs:
- preferred_type = kwargs['preferredType']
- if private_ip is None and 'privateIp' in kwargs:
- private_ip = kwargs['privateIp']
- if resource_tag_specifications is None and 'resourceTagSpecifications' in kwargs:
- resource_tag_specifications = kwargs['resourceTagSpecifications']
- if revert_to_spot is None and 'revertToSpot' in kwargs:
- revert_to_spot = kwargs['revertToSpot']
- if scheduled_tasks is None and 'scheduledTasks' in kwargs:
- scheduled_tasks = kwargs['scheduledTasks']
- if security_group_ids is None and 'securityGroupIds' in kwargs:
- security_group_ids = kwargs['securityGroupIds']
- if shutdown_script is None and 'shutdownScript' in kwargs:
- shutdown_script = kwargs['shutdownScript']
- if subnet_ids is None and 'subnetIds' in kwargs:
- subnet_ids = kwargs['subnetIds']
- if unhealthy_duration is None and 'unhealthyDuration' in kwargs:
- unhealthy_duration = kwargs['unhealthyDuration']
- if user_data is None and 'userData' in kwargs:
- user_data = kwargs['userData']
- if utilize_reserved_instances is None and 'utilizeReservedInstances' in kwargs:
- utilize_reserved_instances = kwargs['utilizeReservedInstances']
- if vpc_id is None and 'vpcId' in kwargs:
- vpc_id = kwargs['vpcId']
-
if auto_healing is not None:
- _setter("auto_healing", auto_healing)
+ pulumi.set(__self__, "auto_healing", auto_healing)
if block_device_mappings is not None:
- _setter("block_device_mappings", block_device_mappings)
+ pulumi.set(__self__, "block_device_mappings", block_device_mappings)
if block_devices_mode is not None:
- _setter("block_devices_mode", block_devices_mode)
+ pulumi.set(__self__, "block_devices_mode", block_devices_mode)
if cpu_credits is not None:
- _setter("cpu_credits", cpu_credits)
+ pulumi.set(__self__, "cpu_credits", cpu_credits)
if deletes is not None:
- _setter("deletes", deletes)
+ pulumi.set(__self__, "deletes", deletes)
if description is not None:
- _setter("description", description)
+ pulumi.set(__self__, "description", description)
if draining_timeout is not None:
- _setter("draining_timeout", draining_timeout)
+ pulumi.set(__self__, "draining_timeout", draining_timeout)
if ebs_optimized is not None:
- _setter("ebs_optimized", ebs_optimized)
+ pulumi.set(__self__, "ebs_optimized", ebs_optimized)
if elastic_ip is not None:
- _setter("elastic_ip", elastic_ip)
+ pulumi.set(__self__, "elastic_ip", elastic_ip)
if enable_monitoring is not None:
- _setter("enable_monitoring", enable_monitoring)
+ pulumi.set(__self__, "enable_monitoring", enable_monitoring)
if fall_back_to_od is not None:
- _setter("fall_back_to_od", fall_back_to_od)
+ pulumi.set(__self__, "fall_back_to_od", fall_back_to_od)
if grace_period is not None:
- _setter("grace_period", grace_period)
+ pulumi.set(__self__, "grace_period", grace_period)
if health_check_type is not None:
- _setter("health_check_type", health_check_type)
+ pulumi.set(__self__, "health_check_type", health_check_type)
if iam_instance_profile is not None:
- _setter("iam_instance_profile", iam_instance_profile)
+ pulumi.set(__self__, "iam_instance_profile", iam_instance_profile)
if image_id is not None:
- _setter("image_id", image_id)
+ pulumi.set(__self__, "image_id", image_id)
if instance_types is not None:
- _setter("instance_types", instance_types)
+ pulumi.set(__self__, "instance_types", instance_types)
if integration_route53 is not None:
- _setter("integration_route53", integration_route53)
+ pulumi.set(__self__, "integration_route53", integration_route53)
if key_pair is not None:
- _setter("key_pair", key_pair)
+ pulumi.set(__self__, "key_pair", key_pair)
if life_cycle is not None:
- _setter("life_cycle", life_cycle)
+ pulumi.set(__self__, "life_cycle", life_cycle)
if load_balancers is not None:
- _setter("load_balancers", load_balancers)
+ pulumi.set(__self__, "load_balancers", load_balancers)
if managed_instance_action is not None:
- _setter("managed_instance_action", managed_instance_action)
+ pulumi.set(__self__, "managed_instance_action", managed_instance_action)
if minimum_instance_lifetime is not None:
- _setter("minimum_instance_lifetime", minimum_instance_lifetime)
+ pulumi.set(__self__, "minimum_instance_lifetime", minimum_instance_lifetime)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if network_interfaces is not None:
- _setter("network_interfaces", network_interfaces)
+ pulumi.set(__self__, "network_interfaces", network_interfaces)
if optimization_windows is not None:
- _setter("optimization_windows", optimization_windows)
+ pulumi.set(__self__, "optimization_windows", optimization_windows)
if orientation is not None:
- _setter("orientation", orientation)
+ pulumi.set(__self__, "orientation", orientation)
if persist_block_devices is not None:
- _setter("persist_block_devices", persist_block_devices)
+ pulumi.set(__self__, "persist_block_devices", persist_block_devices)
if persist_private_ip is not None:
- _setter("persist_private_ip", persist_private_ip)
+ pulumi.set(__self__, "persist_private_ip", persist_private_ip)
if persist_root_device is not None:
- _setter("persist_root_device", persist_root_device)
+ pulumi.set(__self__, "persist_root_device", persist_root_device)
if placement_tenancy is not None:
- _setter("placement_tenancy", placement_tenancy)
+ pulumi.set(__self__, "placement_tenancy", placement_tenancy)
if preferred_type is not None:
- _setter("preferred_type", preferred_type)
+ pulumi.set(__self__, "preferred_type", preferred_type)
if private_ip is not None:
- _setter("private_ip", private_ip)
+ pulumi.set(__self__, "private_ip", private_ip)
if product is not None:
- _setter("product", product)
+ pulumi.set(__self__, "product", product)
if region is not None:
- _setter("region", region)
+ pulumi.set(__self__, "region", region)
if resource_tag_specifications is not None:
- _setter("resource_tag_specifications", resource_tag_specifications)
+ pulumi.set(__self__, "resource_tag_specifications", resource_tag_specifications)
if revert_to_spot is not None:
- _setter("revert_to_spot", revert_to_spot)
+ pulumi.set(__self__, "revert_to_spot", revert_to_spot)
if scheduled_tasks is not None:
- _setter("scheduled_tasks", scheduled_tasks)
+ pulumi.set(__self__, "scheduled_tasks", scheduled_tasks)
if security_group_ids is not None:
- _setter("security_group_ids", security_group_ids)
+ pulumi.set(__self__, "security_group_ids", security_group_ids)
if shutdown_script is not None:
- _setter("shutdown_script", shutdown_script)
+ pulumi.set(__self__, "shutdown_script", shutdown_script)
if subnet_ids is not None:
- _setter("subnet_ids", subnet_ids)
+ pulumi.set(__self__, "subnet_ids", subnet_ids)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
if unhealthy_duration is not None:
- _setter("unhealthy_duration", unhealthy_duration)
+ pulumi.set(__self__, "unhealthy_duration", unhealthy_duration)
if user_data is not None:
- _setter("user_data", user_data)
+ pulumi.set(__self__, "user_data", user_data)
if utilize_reserved_instances is not None:
- _setter("utilize_reserved_instances", utilize_reserved_instances)
+ pulumi.set(__self__, "utilize_reserved_instances", utilize_reserved_instances)
if vpc_id is not None:
- _setter("vpc_id", vpc_id)
+ pulumi.set(__self__, "vpc_id", vpc_id)
@property
@pulumi.getter(name="autoHealing")
@@ -1539,10 +1177,6 @@ def __init__(__self__, resource_name: str, *args, **kwargs):
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
- kwargs = kwargs or {}
- def _setter(key, value):
- kwargs[key] = value
- ManagedInstanceArgs._configure(_setter, **kwargs)
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
@@ -1622,12 +1256,10 @@ def _internal_init(__self__,
if instance_types is None and not opts.urn:
raise TypeError("Missing required property 'instance_types'")
__props__.__dict__["instance_types"] = instance_types
- integration_route53 = _utilities.configure(integration_route53, ManagedInstanceIntegrationRoute53Args, True)
__props__.__dict__["integration_route53"] = integration_route53
__props__.__dict__["key_pair"] = key_pair
__props__.__dict__["life_cycle"] = life_cycle
__props__.__dict__["load_balancers"] = load_balancers
- managed_instance_action = _utilities.configure(managed_instance_action, ManagedInstanceManagedInstanceActionArgs, True)
__props__.__dict__["managed_instance_action"] = managed_instance_action
__props__.__dict__["minimum_instance_lifetime"] = minimum_instance_lifetime
__props__.__dict__["name"] = name
@@ -1647,7 +1279,6 @@ def _internal_init(__self__,
__props__.__dict__["product"] = product
__props__.__dict__["region"] = region
__props__.__dict__["resource_tag_specifications"] = resource_tag_specifications
- revert_to_spot = _utilities.configure(revert_to_spot, ManagedInstanceRevertToSpotArgs, True)
__props__.__dict__["revert_to_spot"] = revert_to_spot
__props__.__dict__["scheduled_tasks"] = scheduled_tasks
__props__.__dict__["security_group_ids"] = security_group_ids
diff --git a/sdk/python/pulumi_spotinst/aws/mr_scalar.py b/sdk/python/pulumi_spotinst/aws/mr_scalar.py
index b26e29bf..039cb64c 100644
--- a/sdk/python/pulumi_spotinst/aws/mr_scalar.py
+++ b/sdk/python/pulumi_spotinst/aws/mr_scalar.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs
from ._inputs import *
@@ -133,365 +133,128 @@ def __init__(__self__, *,
:param pulumi.Input[Sequence[pulumi.Input['MrScalarTerminationPolicyArgs']]] termination_policies: Allows defining termination policies for EMR clusters based on CloudWatch Metrics.
:param pulumi.Input[bool] termination_protected: Specifies whether the Amazon EC2 instances in the cluster are protected from termination by API calls, user intervention, or in the event of a job-flow error.
"""
- MrScalarArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- strategy=strategy,
- additional_info=additional_info,
- additional_primary_security_groups=additional_primary_security_groups,
- additional_replica_security_groups=additional_replica_security_groups,
- applications=applications,
- availability_zones=availability_zones,
- bootstrap_actions_files=bootstrap_actions_files,
- cluster_id=cluster_id,
- configurations_files=configurations_files,
- core_desired_capacity=core_desired_capacity,
- core_ebs_block_devices=core_ebs_block_devices,
- core_ebs_optimized=core_ebs_optimized,
- core_instance_types=core_instance_types,
- core_lifecycle=core_lifecycle,
- core_max_size=core_max_size,
- core_min_size=core_min_size,
- core_scaling_down_policies=core_scaling_down_policies,
- core_scaling_up_policies=core_scaling_up_policies,
- core_unit=core_unit,
- custom_ami_id=custom_ami_id,
- description=description,
- ebs_root_volume_size=ebs_root_volume_size,
- ec2_key_name=ec2_key_name,
- expose_cluster_id=expose_cluster_id,
- instance_weights=instance_weights,
- job_flow_role=job_flow_role,
- keep_job_flow_alive=keep_job_flow_alive,
- log_uri=log_uri,
- managed_primary_security_group=managed_primary_security_group,
- managed_replica_security_group=managed_replica_security_group,
- master_ebs_block_devices=master_ebs_block_devices,
- master_ebs_optimized=master_ebs_optimized,
- master_instance_types=master_instance_types,
- master_lifecycle=master_lifecycle,
- master_target=master_target,
- name=name,
- provisioning_timeout=provisioning_timeout,
- region=region,
- release_label=release_label,
- repo_upgrade_on_boot=repo_upgrade_on_boot,
- retries=retries,
- scheduled_tasks=scheduled_tasks,
- security_config=security_config,
- service_access_security_group=service_access_security_group,
- service_role=service_role,
- steps_files=steps_files,
- tags=tags,
- task_desired_capacity=task_desired_capacity,
- task_ebs_block_devices=task_ebs_block_devices,
- task_ebs_optimized=task_ebs_optimized,
- task_instance_types=task_instance_types,
- task_lifecycle=task_lifecycle,
- task_max_size=task_max_size,
- task_min_size=task_min_size,
- task_scaling_down_policies=task_scaling_down_policies,
- task_scaling_up_policies=task_scaling_up_policies,
- task_unit=task_unit,
- termination_policies=termination_policies,
- termination_protected=termination_protected,
- visible_to_all_users=visible_to_all_users,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- strategy: Optional[pulumi.Input[str]] = None,
- additional_info: Optional[pulumi.Input[str]] = None,
- additional_primary_security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- additional_replica_security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- applications: Optional[pulumi.Input[Sequence[pulumi.Input['MrScalarApplicationArgs']]]] = None,
- availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- bootstrap_actions_files: Optional[pulumi.Input[Sequence[pulumi.Input['MrScalarBootstrapActionsFileArgs']]]] = None,
- cluster_id: Optional[pulumi.Input[str]] = None,
- configurations_files: Optional[pulumi.Input[Sequence[pulumi.Input['MrScalarConfigurationsFileArgs']]]] = None,
- core_desired_capacity: Optional[pulumi.Input[int]] = None,
- core_ebs_block_devices: Optional[pulumi.Input[Sequence[pulumi.Input['MrScalarCoreEbsBlockDeviceArgs']]]] = None,
- core_ebs_optimized: Optional[pulumi.Input[bool]] = None,
- core_instance_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- core_lifecycle: Optional[pulumi.Input[str]] = None,
- core_max_size: Optional[pulumi.Input[int]] = None,
- core_min_size: Optional[pulumi.Input[int]] = None,
- core_scaling_down_policies: Optional[pulumi.Input[Sequence[pulumi.Input['MrScalarCoreScalingDownPolicyArgs']]]] = None,
- core_scaling_up_policies: Optional[pulumi.Input[Sequence[pulumi.Input['MrScalarCoreScalingUpPolicyArgs']]]] = None,
- core_unit: Optional[pulumi.Input[str]] = None,
- custom_ami_id: Optional[pulumi.Input[str]] = None,
- description: Optional[pulumi.Input[str]] = None,
- ebs_root_volume_size: Optional[pulumi.Input[int]] = None,
- ec2_key_name: Optional[pulumi.Input[str]] = None,
- expose_cluster_id: Optional[pulumi.Input[bool]] = None,
- instance_weights: Optional[pulumi.Input[Sequence[pulumi.Input['MrScalarInstanceWeightArgs']]]] = None,
- job_flow_role: Optional[pulumi.Input[str]] = None,
- keep_job_flow_alive: Optional[pulumi.Input[bool]] = None,
- log_uri: Optional[pulumi.Input[str]] = None,
- managed_primary_security_group: Optional[pulumi.Input[str]] = None,
- managed_replica_security_group: Optional[pulumi.Input[str]] = None,
- master_ebs_block_devices: Optional[pulumi.Input[Sequence[pulumi.Input['MrScalarMasterEbsBlockDeviceArgs']]]] = None,
- master_ebs_optimized: Optional[pulumi.Input[bool]] = None,
- master_instance_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- master_lifecycle: Optional[pulumi.Input[str]] = None,
- master_target: Optional[pulumi.Input[int]] = None,
- name: Optional[pulumi.Input[str]] = None,
- provisioning_timeout: Optional[pulumi.Input['MrScalarProvisioningTimeoutArgs']] = None,
- region: Optional[pulumi.Input[str]] = None,
- release_label: Optional[pulumi.Input[str]] = None,
- repo_upgrade_on_boot: Optional[pulumi.Input[str]] = None,
- retries: Optional[pulumi.Input[int]] = None,
- scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['MrScalarScheduledTaskArgs']]]] = None,
- security_config: Optional[pulumi.Input[str]] = None,
- service_access_security_group: Optional[pulumi.Input[str]] = None,
- service_role: Optional[pulumi.Input[str]] = None,
- steps_files: Optional[pulumi.Input[Sequence[pulumi.Input['MrScalarStepsFileArgs']]]] = None,
- tags: Optional[pulumi.Input[Sequence[pulumi.Input['MrScalarTagArgs']]]] = None,
- task_desired_capacity: Optional[pulumi.Input[int]] = None,
- task_ebs_block_devices: Optional[pulumi.Input[Sequence[pulumi.Input['MrScalarTaskEbsBlockDeviceArgs']]]] = None,
- task_ebs_optimized: Optional[pulumi.Input[bool]] = None,
- task_instance_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- task_lifecycle: Optional[pulumi.Input[str]] = None,
- task_max_size: Optional[pulumi.Input[int]] = None,
- task_min_size: Optional[pulumi.Input[int]] = None,
- task_scaling_down_policies: Optional[pulumi.Input[Sequence[pulumi.Input['MrScalarTaskScalingDownPolicyArgs']]]] = None,
- task_scaling_up_policies: Optional[pulumi.Input[Sequence[pulumi.Input['MrScalarTaskScalingUpPolicyArgs']]]] = None,
- task_unit: Optional[pulumi.Input[str]] = None,
- termination_policies: Optional[pulumi.Input[Sequence[pulumi.Input['MrScalarTerminationPolicyArgs']]]] = None,
- termination_protected: Optional[pulumi.Input[bool]] = None,
- visible_to_all_users: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if strategy is None:
- raise TypeError("Missing 'strategy' argument")
- if additional_info is None and 'additionalInfo' in kwargs:
- additional_info = kwargs['additionalInfo']
- if additional_primary_security_groups is None and 'additionalPrimarySecurityGroups' in kwargs:
- additional_primary_security_groups = kwargs['additionalPrimarySecurityGroups']
- if additional_replica_security_groups is None and 'additionalReplicaSecurityGroups' in kwargs:
- additional_replica_security_groups = kwargs['additionalReplicaSecurityGroups']
- if availability_zones is None and 'availabilityZones' in kwargs:
- availability_zones = kwargs['availabilityZones']
- if bootstrap_actions_files is None and 'bootstrapActionsFiles' in kwargs:
- bootstrap_actions_files = kwargs['bootstrapActionsFiles']
- if cluster_id is None and 'clusterId' in kwargs:
- cluster_id = kwargs['clusterId']
- if configurations_files is None and 'configurationsFiles' in kwargs:
- configurations_files = kwargs['configurationsFiles']
- if core_desired_capacity is None and 'coreDesiredCapacity' in kwargs:
- core_desired_capacity = kwargs['coreDesiredCapacity']
- if core_ebs_block_devices is None and 'coreEbsBlockDevices' in kwargs:
- core_ebs_block_devices = kwargs['coreEbsBlockDevices']
- if core_ebs_optimized is None and 'coreEbsOptimized' in kwargs:
- core_ebs_optimized = kwargs['coreEbsOptimized']
- if core_instance_types is None and 'coreInstanceTypes' in kwargs:
- core_instance_types = kwargs['coreInstanceTypes']
- if core_lifecycle is None and 'coreLifecycle' in kwargs:
- core_lifecycle = kwargs['coreLifecycle']
- if core_max_size is None and 'coreMaxSize' in kwargs:
- core_max_size = kwargs['coreMaxSize']
- if core_min_size is None and 'coreMinSize' in kwargs:
- core_min_size = kwargs['coreMinSize']
- if core_scaling_down_policies is None and 'coreScalingDownPolicies' in kwargs:
- core_scaling_down_policies = kwargs['coreScalingDownPolicies']
- if core_scaling_up_policies is None and 'coreScalingUpPolicies' in kwargs:
- core_scaling_up_policies = kwargs['coreScalingUpPolicies']
- if core_unit is None and 'coreUnit' in kwargs:
- core_unit = kwargs['coreUnit']
- if custom_ami_id is None and 'customAmiId' in kwargs:
- custom_ami_id = kwargs['customAmiId']
- if ebs_root_volume_size is None and 'ebsRootVolumeSize' in kwargs:
- ebs_root_volume_size = kwargs['ebsRootVolumeSize']
- if ec2_key_name is None and 'ec2KeyName' in kwargs:
- ec2_key_name = kwargs['ec2KeyName']
- if expose_cluster_id is None and 'exposeClusterId' in kwargs:
- expose_cluster_id = kwargs['exposeClusterId']
- if instance_weights is None and 'instanceWeights' in kwargs:
- instance_weights = kwargs['instanceWeights']
- if job_flow_role is None and 'jobFlowRole' in kwargs:
- job_flow_role = kwargs['jobFlowRole']
- if keep_job_flow_alive is None and 'keepJobFlowAlive' in kwargs:
- keep_job_flow_alive = kwargs['keepJobFlowAlive']
- if log_uri is None and 'logUri' in kwargs:
- log_uri = kwargs['logUri']
- if managed_primary_security_group is None and 'managedPrimarySecurityGroup' in kwargs:
- managed_primary_security_group = kwargs['managedPrimarySecurityGroup']
- if managed_replica_security_group is None and 'managedReplicaSecurityGroup' in kwargs:
- managed_replica_security_group = kwargs['managedReplicaSecurityGroup']
- if master_ebs_block_devices is None and 'masterEbsBlockDevices' in kwargs:
- master_ebs_block_devices = kwargs['masterEbsBlockDevices']
- if master_ebs_optimized is None and 'masterEbsOptimized' in kwargs:
- master_ebs_optimized = kwargs['masterEbsOptimized']
- if master_instance_types is None and 'masterInstanceTypes' in kwargs:
- master_instance_types = kwargs['masterInstanceTypes']
- if master_lifecycle is None and 'masterLifecycle' in kwargs:
- master_lifecycle = kwargs['masterLifecycle']
- if master_target is None and 'masterTarget' in kwargs:
- master_target = kwargs['masterTarget']
- if provisioning_timeout is None and 'provisioningTimeout' in kwargs:
- provisioning_timeout = kwargs['provisioningTimeout']
- if release_label is None and 'releaseLabel' in kwargs:
- release_label = kwargs['releaseLabel']
- if repo_upgrade_on_boot is None and 'repoUpgradeOnBoot' in kwargs:
- repo_upgrade_on_boot = kwargs['repoUpgradeOnBoot']
- if scheduled_tasks is None and 'scheduledTasks' in kwargs:
- scheduled_tasks = kwargs['scheduledTasks']
- if security_config is None and 'securityConfig' in kwargs:
- security_config = kwargs['securityConfig']
- if service_access_security_group is None and 'serviceAccessSecurityGroup' in kwargs:
- service_access_security_group = kwargs['serviceAccessSecurityGroup']
- if service_role is None and 'serviceRole' in kwargs:
- service_role = kwargs['serviceRole']
- if steps_files is None and 'stepsFiles' in kwargs:
- steps_files = kwargs['stepsFiles']
- if task_desired_capacity is None and 'taskDesiredCapacity' in kwargs:
- task_desired_capacity = kwargs['taskDesiredCapacity']
- if task_ebs_block_devices is None and 'taskEbsBlockDevices' in kwargs:
- task_ebs_block_devices = kwargs['taskEbsBlockDevices']
- if task_ebs_optimized is None and 'taskEbsOptimized' in kwargs:
- task_ebs_optimized = kwargs['taskEbsOptimized']
- if task_instance_types is None and 'taskInstanceTypes' in kwargs:
- task_instance_types = kwargs['taskInstanceTypes']
- if task_lifecycle is None and 'taskLifecycle' in kwargs:
- task_lifecycle = kwargs['taskLifecycle']
- if task_max_size is None and 'taskMaxSize' in kwargs:
- task_max_size = kwargs['taskMaxSize']
- if task_min_size is None and 'taskMinSize' in kwargs:
- task_min_size = kwargs['taskMinSize']
- if task_scaling_down_policies is None and 'taskScalingDownPolicies' in kwargs:
- task_scaling_down_policies = kwargs['taskScalingDownPolicies']
- if task_scaling_up_policies is None and 'taskScalingUpPolicies' in kwargs:
- task_scaling_up_policies = kwargs['taskScalingUpPolicies']
- if task_unit is None and 'taskUnit' in kwargs:
- task_unit = kwargs['taskUnit']
- if termination_policies is None and 'terminationPolicies' in kwargs:
- termination_policies = kwargs['terminationPolicies']
- if termination_protected is None and 'terminationProtected' in kwargs:
- termination_protected = kwargs['terminationProtected']
- if visible_to_all_users is None and 'visibleToAllUsers' in kwargs:
- visible_to_all_users = kwargs['visibleToAllUsers']
-
- _setter("strategy", strategy)
+ pulumi.set(__self__, "strategy", strategy)
if additional_info is not None:
- _setter("additional_info", additional_info)
+ pulumi.set(__self__, "additional_info", additional_info)
if additional_primary_security_groups is not None:
- _setter("additional_primary_security_groups", additional_primary_security_groups)
+ pulumi.set(__self__, "additional_primary_security_groups", additional_primary_security_groups)
if additional_replica_security_groups is not None:
- _setter("additional_replica_security_groups", additional_replica_security_groups)
+ pulumi.set(__self__, "additional_replica_security_groups", additional_replica_security_groups)
if applications is not None:
- _setter("applications", applications)
+ pulumi.set(__self__, "applications", applications)
if availability_zones is not None:
- _setter("availability_zones", availability_zones)
+ pulumi.set(__self__, "availability_zones", availability_zones)
if bootstrap_actions_files is not None:
- _setter("bootstrap_actions_files", bootstrap_actions_files)
+ pulumi.set(__self__, "bootstrap_actions_files", bootstrap_actions_files)
if cluster_id is not None:
- _setter("cluster_id", cluster_id)
+ pulumi.set(__self__, "cluster_id", cluster_id)
if configurations_files is not None:
- _setter("configurations_files", configurations_files)
+ pulumi.set(__self__, "configurations_files", configurations_files)
if core_desired_capacity is not None:
- _setter("core_desired_capacity", core_desired_capacity)
+ pulumi.set(__self__, "core_desired_capacity", core_desired_capacity)
if core_ebs_block_devices is not None:
- _setter("core_ebs_block_devices", core_ebs_block_devices)
+ pulumi.set(__self__, "core_ebs_block_devices", core_ebs_block_devices)
if core_ebs_optimized is not None:
- _setter("core_ebs_optimized", core_ebs_optimized)
+ pulumi.set(__self__, "core_ebs_optimized", core_ebs_optimized)
if core_instance_types is not None:
- _setter("core_instance_types", core_instance_types)
+ pulumi.set(__self__, "core_instance_types", core_instance_types)
if core_lifecycle is not None:
- _setter("core_lifecycle", core_lifecycle)
+ pulumi.set(__self__, "core_lifecycle", core_lifecycle)
if core_max_size is not None:
- _setter("core_max_size", core_max_size)
+ pulumi.set(__self__, "core_max_size", core_max_size)
if core_min_size is not None:
- _setter("core_min_size", core_min_size)
+ pulumi.set(__self__, "core_min_size", core_min_size)
if core_scaling_down_policies is not None:
- _setter("core_scaling_down_policies", core_scaling_down_policies)
+ pulumi.set(__self__, "core_scaling_down_policies", core_scaling_down_policies)
if core_scaling_up_policies is not None:
- _setter("core_scaling_up_policies", core_scaling_up_policies)
+ pulumi.set(__self__, "core_scaling_up_policies", core_scaling_up_policies)
if core_unit is not None:
- _setter("core_unit", core_unit)
+ pulumi.set(__self__, "core_unit", core_unit)
if custom_ami_id is not None:
- _setter("custom_ami_id", custom_ami_id)
+ pulumi.set(__self__, "custom_ami_id", custom_ami_id)
if description is not None:
- _setter("description", description)
+ pulumi.set(__self__, "description", description)
if ebs_root_volume_size is not None:
- _setter("ebs_root_volume_size", ebs_root_volume_size)
+ pulumi.set(__self__, "ebs_root_volume_size", ebs_root_volume_size)
if ec2_key_name is not None:
- _setter("ec2_key_name", ec2_key_name)
+ pulumi.set(__self__, "ec2_key_name", ec2_key_name)
if expose_cluster_id is not None:
- _setter("expose_cluster_id", expose_cluster_id)
+ pulumi.set(__self__, "expose_cluster_id", expose_cluster_id)
if instance_weights is not None:
- _setter("instance_weights", instance_weights)
+ pulumi.set(__self__, "instance_weights", instance_weights)
if job_flow_role is not None:
- _setter("job_flow_role", job_flow_role)
+ pulumi.set(__self__, "job_flow_role", job_flow_role)
if keep_job_flow_alive is not None:
- _setter("keep_job_flow_alive", keep_job_flow_alive)
+ pulumi.set(__self__, "keep_job_flow_alive", keep_job_flow_alive)
if log_uri is not None:
- _setter("log_uri", log_uri)
+ pulumi.set(__self__, "log_uri", log_uri)
if managed_primary_security_group is not None:
- _setter("managed_primary_security_group", managed_primary_security_group)
+ pulumi.set(__self__, "managed_primary_security_group", managed_primary_security_group)
if managed_replica_security_group is not None:
- _setter("managed_replica_security_group", managed_replica_security_group)
+ pulumi.set(__self__, "managed_replica_security_group", managed_replica_security_group)
if master_ebs_block_devices is not None:
- _setter("master_ebs_block_devices", master_ebs_block_devices)
+ pulumi.set(__self__, "master_ebs_block_devices", master_ebs_block_devices)
if master_ebs_optimized is not None:
- _setter("master_ebs_optimized", master_ebs_optimized)
+ pulumi.set(__self__, "master_ebs_optimized", master_ebs_optimized)
if master_instance_types is not None:
- _setter("master_instance_types", master_instance_types)
+ pulumi.set(__self__, "master_instance_types", master_instance_types)
if master_lifecycle is not None:
- _setter("master_lifecycle", master_lifecycle)
+ pulumi.set(__self__, "master_lifecycle", master_lifecycle)
if master_target is not None:
- _setter("master_target", master_target)
+ pulumi.set(__self__, "master_target", master_target)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if provisioning_timeout is not None:
- _setter("provisioning_timeout", provisioning_timeout)
+ pulumi.set(__self__, "provisioning_timeout", provisioning_timeout)
if region is not None:
- _setter("region", region)
+ pulumi.set(__self__, "region", region)
if release_label is not None:
- _setter("release_label", release_label)
+ pulumi.set(__self__, "release_label", release_label)
if repo_upgrade_on_boot is not None:
- _setter("repo_upgrade_on_boot", repo_upgrade_on_boot)
+ pulumi.set(__self__, "repo_upgrade_on_boot", repo_upgrade_on_boot)
if retries is not None:
- _setter("retries", retries)
+ pulumi.set(__self__, "retries", retries)
if scheduled_tasks is not None:
- _setter("scheduled_tasks", scheduled_tasks)
+ pulumi.set(__self__, "scheduled_tasks", scheduled_tasks)
if security_config is not None:
- _setter("security_config", security_config)
+ pulumi.set(__self__, "security_config", security_config)
if service_access_security_group is not None:
- _setter("service_access_security_group", service_access_security_group)
+ pulumi.set(__self__, "service_access_security_group", service_access_security_group)
if service_role is not None:
- _setter("service_role", service_role)
+ pulumi.set(__self__, "service_role", service_role)
if steps_files is not None:
- _setter("steps_files", steps_files)
+ pulumi.set(__self__, "steps_files", steps_files)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
if task_desired_capacity is not None:
- _setter("task_desired_capacity", task_desired_capacity)
+ pulumi.set(__self__, "task_desired_capacity", task_desired_capacity)
if task_ebs_block_devices is not None:
- _setter("task_ebs_block_devices", task_ebs_block_devices)
+ pulumi.set(__self__, "task_ebs_block_devices", task_ebs_block_devices)
if task_ebs_optimized is not None:
- _setter("task_ebs_optimized", task_ebs_optimized)
+ pulumi.set(__self__, "task_ebs_optimized", task_ebs_optimized)
if task_instance_types is not None:
- _setter("task_instance_types", task_instance_types)
+ pulumi.set(__self__, "task_instance_types", task_instance_types)
if task_lifecycle is not None:
- _setter("task_lifecycle", task_lifecycle)
+ pulumi.set(__self__, "task_lifecycle", task_lifecycle)
if task_max_size is not None:
- _setter("task_max_size", task_max_size)
+ pulumi.set(__self__, "task_max_size", task_max_size)
if task_min_size is not None:
- _setter("task_min_size", task_min_size)
+ pulumi.set(__self__, "task_min_size", task_min_size)
if task_scaling_down_policies is not None:
- _setter("task_scaling_down_policies", task_scaling_down_policies)
+ pulumi.set(__self__, "task_scaling_down_policies", task_scaling_down_policies)
if task_scaling_up_policies is not None:
- _setter("task_scaling_up_policies", task_scaling_up_policies)
+ pulumi.set(__self__, "task_scaling_up_policies", task_scaling_up_policies)
if task_unit is not None:
- _setter("task_unit", task_unit)
+ pulumi.set(__self__, "task_unit", task_unit)
if termination_policies is not None:
- _setter("termination_policies", termination_policies)
+ pulumi.set(__self__, "termination_policies", termination_policies)
if termination_protected is not None:
- _setter("termination_protected", termination_protected)
+ pulumi.set(__self__, "termination_protected", termination_protected)
if visible_to_all_users is not None:
warnings.warn("""This field has been removed from our API and is no longer functional.""", DeprecationWarning)
pulumi.log.warn("""visible_to_all_users is deprecated: This field has been removed from our API and is no longer functional.""")
if visible_to_all_users is not None:
- _setter("visible_to_all_users", visible_to_all_users)
+ pulumi.set(__self__, "visible_to_all_users", visible_to_all_users)
@property
@pulumi.getter
@@ -1320,370 +1083,131 @@ def __init__(__self__, *,
:param pulumi.Input[Sequence[pulumi.Input['MrScalarTerminationPolicyArgs']]] termination_policies: Allows defining termination policies for EMR clusters based on CloudWatch Metrics.
:param pulumi.Input[bool] termination_protected: Specifies whether the Amazon EC2 instances in the cluster are protected from termination by API calls, user intervention, or in the event of a job-flow error.
"""
- _MrScalarState._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- additional_info=additional_info,
- additional_primary_security_groups=additional_primary_security_groups,
- additional_replica_security_groups=additional_replica_security_groups,
- applications=applications,
- availability_zones=availability_zones,
- bootstrap_actions_files=bootstrap_actions_files,
- cluster_id=cluster_id,
- configurations_files=configurations_files,
- core_desired_capacity=core_desired_capacity,
- core_ebs_block_devices=core_ebs_block_devices,
- core_ebs_optimized=core_ebs_optimized,
- core_instance_types=core_instance_types,
- core_lifecycle=core_lifecycle,
- core_max_size=core_max_size,
- core_min_size=core_min_size,
- core_scaling_down_policies=core_scaling_down_policies,
- core_scaling_up_policies=core_scaling_up_policies,
- core_unit=core_unit,
- custom_ami_id=custom_ami_id,
- description=description,
- ebs_root_volume_size=ebs_root_volume_size,
- ec2_key_name=ec2_key_name,
- expose_cluster_id=expose_cluster_id,
- instance_weights=instance_weights,
- job_flow_role=job_flow_role,
- keep_job_flow_alive=keep_job_flow_alive,
- log_uri=log_uri,
- managed_primary_security_group=managed_primary_security_group,
- managed_replica_security_group=managed_replica_security_group,
- master_ebs_block_devices=master_ebs_block_devices,
- master_ebs_optimized=master_ebs_optimized,
- master_instance_types=master_instance_types,
- master_lifecycle=master_lifecycle,
- master_target=master_target,
- name=name,
- output_cluster_id=output_cluster_id,
- provisioning_timeout=provisioning_timeout,
- region=region,
- release_label=release_label,
- repo_upgrade_on_boot=repo_upgrade_on_boot,
- retries=retries,
- scheduled_tasks=scheduled_tasks,
- security_config=security_config,
- service_access_security_group=service_access_security_group,
- service_role=service_role,
- steps_files=steps_files,
- strategy=strategy,
- tags=tags,
- task_desired_capacity=task_desired_capacity,
- task_ebs_block_devices=task_ebs_block_devices,
- task_ebs_optimized=task_ebs_optimized,
- task_instance_types=task_instance_types,
- task_lifecycle=task_lifecycle,
- task_max_size=task_max_size,
- task_min_size=task_min_size,
- task_scaling_down_policies=task_scaling_down_policies,
- task_scaling_up_policies=task_scaling_up_policies,
- task_unit=task_unit,
- termination_policies=termination_policies,
- termination_protected=termination_protected,
- visible_to_all_users=visible_to_all_users,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- additional_info: Optional[pulumi.Input[str]] = None,
- additional_primary_security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- additional_replica_security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- applications: Optional[pulumi.Input[Sequence[pulumi.Input['MrScalarApplicationArgs']]]] = None,
- availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- bootstrap_actions_files: Optional[pulumi.Input[Sequence[pulumi.Input['MrScalarBootstrapActionsFileArgs']]]] = None,
- cluster_id: Optional[pulumi.Input[str]] = None,
- configurations_files: Optional[pulumi.Input[Sequence[pulumi.Input['MrScalarConfigurationsFileArgs']]]] = None,
- core_desired_capacity: Optional[pulumi.Input[int]] = None,
- core_ebs_block_devices: Optional[pulumi.Input[Sequence[pulumi.Input['MrScalarCoreEbsBlockDeviceArgs']]]] = None,
- core_ebs_optimized: Optional[pulumi.Input[bool]] = None,
- core_instance_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- core_lifecycle: Optional[pulumi.Input[str]] = None,
- core_max_size: Optional[pulumi.Input[int]] = None,
- core_min_size: Optional[pulumi.Input[int]] = None,
- core_scaling_down_policies: Optional[pulumi.Input[Sequence[pulumi.Input['MrScalarCoreScalingDownPolicyArgs']]]] = None,
- core_scaling_up_policies: Optional[pulumi.Input[Sequence[pulumi.Input['MrScalarCoreScalingUpPolicyArgs']]]] = None,
- core_unit: Optional[pulumi.Input[str]] = None,
- custom_ami_id: Optional[pulumi.Input[str]] = None,
- description: Optional[pulumi.Input[str]] = None,
- ebs_root_volume_size: Optional[pulumi.Input[int]] = None,
- ec2_key_name: Optional[pulumi.Input[str]] = None,
- expose_cluster_id: Optional[pulumi.Input[bool]] = None,
- instance_weights: Optional[pulumi.Input[Sequence[pulumi.Input['MrScalarInstanceWeightArgs']]]] = None,
- job_flow_role: Optional[pulumi.Input[str]] = None,
- keep_job_flow_alive: Optional[pulumi.Input[bool]] = None,
- log_uri: Optional[pulumi.Input[str]] = None,
- managed_primary_security_group: Optional[pulumi.Input[str]] = None,
- managed_replica_security_group: Optional[pulumi.Input[str]] = None,
- master_ebs_block_devices: Optional[pulumi.Input[Sequence[pulumi.Input['MrScalarMasterEbsBlockDeviceArgs']]]] = None,
- master_ebs_optimized: Optional[pulumi.Input[bool]] = None,
- master_instance_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- master_lifecycle: Optional[pulumi.Input[str]] = None,
- master_target: Optional[pulumi.Input[int]] = None,
- name: Optional[pulumi.Input[str]] = None,
- output_cluster_id: Optional[pulumi.Input[str]] = None,
- provisioning_timeout: Optional[pulumi.Input['MrScalarProvisioningTimeoutArgs']] = None,
- region: Optional[pulumi.Input[str]] = None,
- release_label: Optional[pulumi.Input[str]] = None,
- repo_upgrade_on_boot: Optional[pulumi.Input[str]] = None,
- retries: Optional[pulumi.Input[int]] = None,
- scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['MrScalarScheduledTaskArgs']]]] = None,
- security_config: Optional[pulumi.Input[str]] = None,
- service_access_security_group: Optional[pulumi.Input[str]] = None,
- service_role: Optional[pulumi.Input[str]] = None,
- steps_files: Optional[pulumi.Input[Sequence[pulumi.Input['MrScalarStepsFileArgs']]]] = None,
- strategy: Optional[pulumi.Input[str]] = None,
- tags: Optional[pulumi.Input[Sequence[pulumi.Input['MrScalarTagArgs']]]] = None,
- task_desired_capacity: Optional[pulumi.Input[int]] = None,
- task_ebs_block_devices: Optional[pulumi.Input[Sequence[pulumi.Input['MrScalarTaskEbsBlockDeviceArgs']]]] = None,
- task_ebs_optimized: Optional[pulumi.Input[bool]] = None,
- task_instance_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- task_lifecycle: Optional[pulumi.Input[str]] = None,
- task_max_size: Optional[pulumi.Input[int]] = None,
- task_min_size: Optional[pulumi.Input[int]] = None,
- task_scaling_down_policies: Optional[pulumi.Input[Sequence[pulumi.Input['MrScalarTaskScalingDownPolicyArgs']]]] = None,
- task_scaling_up_policies: Optional[pulumi.Input[Sequence[pulumi.Input['MrScalarTaskScalingUpPolicyArgs']]]] = None,
- task_unit: Optional[pulumi.Input[str]] = None,
- termination_policies: Optional[pulumi.Input[Sequence[pulumi.Input['MrScalarTerminationPolicyArgs']]]] = None,
- termination_protected: Optional[pulumi.Input[bool]] = None,
- visible_to_all_users: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if additional_info is None and 'additionalInfo' in kwargs:
- additional_info = kwargs['additionalInfo']
- if additional_primary_security_groups is None and 'additionalPrimarySecurityGroups' in kwargs:
- additional_primary_security_groups = kwargs['additionalPrimarySecurityGroups']
- if additional_replica_security_groups is None and 'additionalReplicaSecurityGroups' in kwargs:
- additional_replica_security_groups = kwargs['additionalReplicaSecurityGroups']
- if availability_zones is None and 'availabilityZones' in kwargs:
- availability_zones = kwargs['availabilityZones']
- if bootstrap_actions_files is None and 'bootstrapActionsFiles' in kwargs:
- bootstrap_actions_files = kwargs['bootstrapActionsFiles']
- if cluster_id is None and 'clusterId' in kwargs:
- cluster_id = kwargs['clusterId']
- if configurations_files is None and 'configurationsFiles' in kwargs:
- configurations_files = kwargs['configurationsFiles']
- if core_desired_capacity is None and 'coreDesiredCapacity' in kwargs:
- core_desired_capacity = kwargs['coreDesiredCapacity']
- if core_ebs_block_devices is None and 'coreEbsBlockDevices' in kwargs:
- core_ebs_block_devices = kwargs['coreEbsBlockDevices']
- if core_ebs_optimized is None and 'coreEbsOptimized' in kwargs:
- core_ebs_optimized = kwargs['coreEbsOptimized']
- if core_instance_types is None and 'coreInstanceTypes' in kwargs:
- core_instance_types = kwargs['coreInstanceTypes']
- if core_lifecycle is None and 'coreLifecycle' in kwargs:
- core_lifecycle = kwargs['coreLifecycle']
- if core_max_size is None and 'coreMaxSize' in kwargs:
- core_max_size = kwargs['coreMaxSize']
- if core_min_size is None and 'coreMinSize' in kwargs:
- core_min_size = kwargs['coreMinSize']
- if core_scaling_down_policies is None and 'coreScalingDownPolicies' in kwargs:
- core_scaling_down_policies = kwargs['coreScalingDownPolicies']
- if core_scaling_up_policies is None and 'coreScalingUpPolicies' in kwargs:
- core_scaling_up_policies = kwargs['coreScalingUpPolicies']
- if core_unit is None and 'coreUnit' in kwargs:
- core_unit = kwargs['coreUnit']
- if custom_ami_id is None and 'customAmiId' in kwargs:
- custom_ami_id = kwargs['customAmiId']
- if ebs_root_volume_size is None and 'ebsRootVolumeSize' in kwargs:
- ebs_root_volume_size = kwargs['ebsRootVolumeSize']
- if ec2_key_name is None and 'ec2KeyName' in kwargs:
- ec2_key_name = kwargs['ec2KeyName']
- if expose_cluster_id is None and 'exposeClusterId' in kwargs:
- expose_cluster_id = kwargs['exposeClusterId']
- if instance_weights is None and 'instanceWeights' in kwargs:
- instance_weights = kwargs['instanceWeights']
- if job_flow_role is None and 'jobFlowRole' in kwargs:
- job_flow_role = kwargs['jobFlowRole']
- if keep_job_flow_alive is None and 'keepJobFlowAlive' in kwargs:
- keep_job_flow_alive = kwargs['keepJobFlowAlive']
- if log_uri is None and 'logUri' in kwargs:
- log_uri = kwargs['logUri']
- if managed_primary_security_group is None and 'managedPrimarySecurityGroup' in kwargs:
- managed_primary_security_group = kwargs['managedPrimarySecurityGroup']
- if managed_replica_security_group is None and 'managedReplicaSecurityGroup' in kwargs:
- managed_replica_security_group = kwargs['managedReplicaSecurityGroup']
- if master_ebs_block_devices is None and 'masterEbsBlockDevices' in kwargs:
- master_ebs_block_devices = kwargs['masterEbsBlockDevices']
- if master_ebs_optimized is None and 'masterEbsOptimized' in kwargs:
- master_ebs_optimized = kwargs['masterEbsOptimized']
- if master_instance_types is None and 'masterInstanceTypes' in kwargs:
- master_instance_types = kwargs['masterInstanceTypes']
- if master_lifecycle is None and 'masterLifecycle' in kwargs:
- master_lifecycle = kwargs['masterLifecycle']
- if master_target is None and 'masterTarget' in kwargs:
- master_target = kwargs['masterTarget']
- if output_cluster_id is None and 'outputClusterId' in kwargs:
- output_cluster_id = kwargs['outputClusterId']
- if provisioning_timeout is None and 'provisioningTimeout' in kwargs:
- provisioning_timeout = kwargs['provisioningTimeout']
- if release_label is None and 'releaseLabel' in kwargs:
- release_label = kwargs['releaseLabel']
- if repo_upgrade_on_boot is None and 'repoUpgradeOnBoot' in kwargs:
- repo_upgrade_on_boot = kwargs['repoUpgradeOnBoot']
- if scheduled_tasks is None and 'scheduledTasks' in kwargs:
- scheduled_tasks = kwargs['scheduledTasks']
- if security_config is None and 'securityConfig' in kwargs:
- security_config = kwargs['securityConfig']
- if service_access_security_group is None and 'serviceAccessSecurityGroup' in kwargs:
- service_access_security_group = kwargs['serviceAccessSecurityGroup']
- if service_role is None and 'serviceRole' in kwargs:
- service_role = kwargs['serviceRole']
- if steps_files is None and 'stepsFiles' in kwargs:
- steps_files = kwargs['stepsFiles']
- if task_desired_capacity is None and 'taskDesiredCapacity' in kwargs:
- task_desired_capacity = kwargs['taskDesiredCapacity']
- if task_ebs_block_devices is None and 'taskEbsBlockDevices' in kwargs:
- task_ebs_block_devices = kwargs['taskEbsBlockDevices']
- if task_ebs_optimized is None and 'taskEbsOptimized' in kwargs:
- task_ebs_optimized = kwargs['taskEbsOptimized']
- if task_instance_types is None and 'taskInstanceTypes' in kwargs:
- task_instance_types = kwargs['taskInstanceTypes']
- if task_lifecycle is None and 'taskLifecycle' in kwargs:
- task_lifecycle = kwargs['taskLifecycle']
- if task_max_size is None and 'taskMaxSize' in kwargs:
- task_max_size = kwargs['taskMaxSize']
- if task_min_size is None and 'taskMinSize' in kwargs:
- task_min_size = kwargs['taskMinSize']
- if task_scaling_down_policies is None and 'taskScalingDownPolicies' in kwargs:
- task_scaling_down_policies = kwargs['taskScalingDownPolicies']
- if task_scaling_up_policies is None and 'taskScalingUpPolicies' in kwargs:
- task_scaling_up_policies = kwargs['taskScalingUpPolicies']
- if task_unit is None and 'taskUnit' in kwargs:
- task_unit = kwargs['taskUnit']
- if termination_policies is None and 'terminationPolicies' in kwargs:
- termination_policies = kwargs['terminationPolicies']
- if termination_protected is None and 'terminationProtected' in kwargs:
- termination_protected = kwargs['terminationProtected']
- if visible_to_all_users is None and 'visibleToAllUsers' in kwargs:
- visible_to_all_users = kwargs['visibleToAllUsers']
-
if additional_info is not None:
- _setter("additional_info", additional_info)
+ pulumi.set(__self__, "additional_info", additional_info)
if additional_primary_security_groups is not None:
- _setter("additional_primary_security_groups", additional_primary_security_groups)
+ pulumi.set(__self__, "additional_primary_security_groups", additional_primary_security_groups)
if additional_replica_security_groups is not None:
- _setter("additional_replica_security_groups", additional_replica_security_groups)
+ pulumi.set(__self__, "additional_replica_security_groups", additional_replica_security_groups)
if applications is not None:
- _setter("applications", applications)
+ pulumi.set(__self__, "applications", applications)
if availability_zones is not None:
- _setter("availability_zones", availability_zones)
+ pulumi.set(__self__, "availability_zones", availability_zones)
if bootstrap_actions_files is not None:
- _setter("bootstrap_actions_files", bootstrap_actions_files)
+ pulumi.set(__self__, "bootstrap_actions_files", bootstrap_actions_files)
if cluster_id is not None:
- _setter("cluster_id", cluster_id)
+ pulumi.set(__self__, "cluster_id", cluster_id)
if configurations_files is not None:
- _setter("configurations_files", configurations_files)
+ pulumi.set(__self__, "configurations_files", configurations_files)
if core_desired_capacity is not None:
- _setter("core_desired_capacity", core_desired_capacity)
+ pulumi.set(__self__, "core_desired_capacity", core_desired_capacity)
if core_ebs_block_devices is not None:
- _setter("core_ebs_block_devices", core_ebs_block_devices)
+ pulumi.set(__self__, "core_ebs_block_devices", core_ebs_block_devices)
if core_ebs_optimized is not None:
- _setter("core_ebs_optimized", core_ebs_optimized)
+ pulumi.set(__self__, "core_ebs_optimized", core_ebs_optimized)
if core_instance_types is not None:
- _setter("core_instance_types", core_instance_types)
+ pulumi.set(__self__, "core_instance_types", core_instance_types)
if core_lifecycle is not None:
- _setter("core_lifecycle", core_lifecycle)
+ pulumi.set(__self__, "core_lifecycle", core_lifecycle)
if core_max_size is not None:
- _setter("core_max_size", core_max_size)
+ pulumi.set(__self__, "core_max_size", core_max_size)
if core_min_size is not None:
- _setter("core_min_size", core_min_size)
+ pulumi.set(__self__, "core_min_size", core_min_size)
if core_scaling_down_policies is not None:
- _setter("core_scaling_down_policies", core_scaling_down_policies)
+ pulumi.set(__self__, "core_scaling_down_policies", core_scaling_down_policies)
if core_scaling_up_policies is not None:
- _setter("core_scaling_up_policies", core_scaling_up_policies)
+ pulumi.set(__self__, "core_scaling_up_policies", core_scaling_up_policies)
if core_unit is not None:
- _setter("core_unit", core_unit)
+ pulumi.set(__self__, "core_unit", core_unit)
if custom_ami_id is not None:
- _setter("custom_ami_id", custom_ami_id)
+ pulumi.set(__self__, "custom_ami_id", custom_ami_id)
if description is not None:
- _setter("description", description)
+ pulumi.set(__self__, "description", description)
if ebs_root_volume_size is not None:
- _setter("ebs_root_volume_size", ebs_root_volume_size)
+ pulumi.set(__self__, "ebs_root_volume_size", ebs_root_volume_size)
if ec2_key_name is not None:
- _setter("ec2_key_name", ec2_key_name)
+ pulumi.set(__self__, "ec2_key_name", ec2_key_name)
if expose_cluster_id is not None:
- _setter("expose_cluster_id", expose_cluster_id)
+ pulumi.set(__self__, "expose_cluster_id", expose_cluster_id)
if instance_weights is not None:
- _setter("instance_weights", instance_weights)
+ pulumi.set(__self__, "instance_weights", instance_weights)
if job_flow_role is not None:
- _setter("job_flow_role", job_flow_role)
+ pulumi.set(__self__, "job_flow_role", job_flow_role)
if keep_job_flow_alive is not None:
- _setter("keep_job_flow_alive", keep_job_flow_alive)
+ pulumi.set(__self__, "keep_job_flow_alive", keep_job_flow_alive)
if log_uri is not None:
- _setter("log_uri", log_uri)
+ pulumi.set(__self__, "log_uri", log_uri)
if managed_primary_security_group is not None:
- _setter("managed_primary_security_group", managed_primary_security_group)
+ pulumi.set(__self__, "managed_primary_security_group", managed_primary_security_group)
if managed_replica_security_group is not None:
- _setter("managed_replica_security_group", managed_replica_security_group)
+ pulumi.set(__self__, "managed_replica_security_group", managed_replica_security_group)
if master_ebs_block_devices is not None:
- _setter("master_ebs_block_devices", master_ebs_block_devices)
+ pulumi.set(__self__, "master_ebs_block_devices", master_ebs_block_devices)
if master_ebs_optimized is not None:
- _setter("master_ebs_optimized", master_ebs_optimized)
+ pulumi.set(__self__, "master_ebs_optimized", master_ebs_optimized)
if master_instance_types is not None:
- _setter("master_instance_types", master_instance_types)
+ pulumi.set(__self__, "master_instance_types", master_instance_types)
if master_lifecycle is not None:
- _setter("master_lifecycle", master_lifecycle)
+ pulumi.set(__self__, "master_lifecycle", master_lifecycle)
if master_target is not None:
- _setter("master_target", master_target)
+ pulumi.set(__self__, "master_target", master_target)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if output_cluster_id is not None:
- _setter("output_cluster_id", output_cluster_id)
+ pulumi.set(__self__, "output_cluster_id", output_cluster_id)
if provisioning_timeout is not None:
- _setter("provisioning_timeout", provisioning_timeout)
+ pulumi.set(__self__, "provisioning_timeout", provisioning_timeout)
if region is not None:
- _setter("region", region)
+ pulumi.set(__self__, "region", region)
if release_label is not None:
- _setter("release_label", release_label)
+ pulumi.set(__self__, "release_label", release_label)
if repo_upgrade_on_boot is not None:
- _setter("repo_upgrade_on_boot", repo_upgrade_on_boot)
+ pulumi.set(__self__, "repo_upgrade_on_boot", repo_upgrade_on_boot)
if retries is not None:
- _setter("retries", retries)
+ pulumi.set(__self__, "retries", retries)
if scheduled_tasks is not None:
- _setter("scheduled_tasks", scheduled_tasks)
+ pulumi.set(__self__, "scheduled_tasks", scheduled_tasks)
if security_config is not None:
- _setter("security_config", security_config)
+ pulumi.set(__self__, "security_config", security_config)
if service_access_security_group is not None:
- _setter("service_access_security_group", service_access_security_group)
+ pulumi.set(__self__, "service_access_security_group", service_access_security_group)
if service_role is not None:
- _setter("service_role", service_role)
+ pulumi.set(__self__, "service_role", service_role)
if steps_files is not None:
- _setter("steps_files", steps_files)
+ pulumi.set(__self__, "steps_files", steps_files)
if strategy is not None:
- _setter("strategy", strategy)
+ pulumi.set(__self__, "strategy", strategy)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
if task_desired_capacity is not None:
- _setter("task_desired_capacity", task_desired_capacity)
+ pulumi.set(__self__, "task_desired_capacity", task_desired_capacity)
if task_ebs_block_devices is not None:
- _setter("task_ebs_block_devices", task_ebs_block_devices)
+ pulumi.set(__self__, "task_ebs_block_devices", task_ebs_block_devices)
if task_ebs_optimized is not None:
- _setter("task_ebs_optimized", task_ebs_optimized)
+ pulumi.set(__self__, "task_ebs_optimized", task_ebs_optimized)
if task_instance_types is not None:
- _setter("task_instance_types", task_instance_types)
+ pulumi.set(__self__, "task_instance_types", task_instance_types)
if task_lifecycle is not None:
- _setter("task_lifecycle", task_lifecycle)
+ pulumi.set(__self__, "task_lifecycle", task_lifecycle)
if task_max_size is not None:
- _setter("task_max_size", task_max_size)
+ pulumi.set(__self__, "task_max_size", task_max_size)
if task_min_size is not None:
- _setter("task_min_size", task_min_size)
+ pulumi.set(__self__, "task_min_size", task_min_size)
if task_scaling_down_policies is not None:
- _setter("task_scaling_down_policies", task_scaling_down_policies)
+ pulumi.set(__self__, "task_scaling_down_policies", task_scaling_down_policies)
if task_scaling_up_policies is not None:
- _setter("task_scaling_up_policies", task_scaling_up_policies)
+ pulumi.set(__self__, "task_scaling_up_policies", task_scaling_up_policies)
if task_unit is not None:
- _setter("task_unit", task_unit)
+ pulumi.set(__self__, "task_unit", task_unit)
if termination_policies is not None:
- _setter("termination_policies", termination_policies)
+ pulumi.set(__self__, "termination_policies", termination_policies)
if termination_protected is not None:
- _setter("termination_protected", termination_protected)
+ pulumi.set(__self__, "termination_protected", termination_protected)
if visible_to_all_users is not None:
warnings.warn("""This field has been removed from our API and is no longer functional.""", DeprecationWarning)
pulumi.log.warn("""visible_to_all_users is deprecated: This field has been removed from our API and is no longer functional.""")
if visible_to_all_users is not None:
- _setter("visible_to_all_users", visible_to_all_users)
+ pulumi.set(__self__, "visible_to_all_users", visible_to_all_users)
@property
@pulumi.getter(name="additionalInfo")
@@ -2991,10 +2515,6 @@ def __init__(__self__, resource_name: str, *args, **kwargs):
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
- kwargs = kwargs or {}
- def _setter(key, value):
- kwargs[key] = value
- MrScalarArgs._configure(_setter, **kwargs)
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
@@ -3104,7 +2624,6 @@ def _internal_init(__self__,
__props__.__dict__["master_lifecycle"] = master_lifecycle
__props__.__dict__["master_target"] = master_target
__props__.__dict__["name"] = name
- provisioning_timeout = _utilities.configure(provisioning_timeout, MrScalarProvisioningTimeoutArgs, True)
__props__.__dict__["provisioning_timeout"] = provisioning_timeout
__props__.__dict__["region"] = region
__props__.__dict__["release_label"] = release_label
diff --git a/sdk/python/pulumi_spotinst/aws/ocean.py b/sdk/python/pulumi_spotinst/aws/ocean.py
index fd31316e..937f9405 100644
--- a/sdk/python/pulumi_spotinst/aws/ocean.py
+++ b/sdk/python/pulumi_spotinst/aws/ocean.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs
from ._inputs import *
@@ -92,227 +92,80 @@ def __init__(__self__, *,
:param pulumi.Input[bool] utilize_reserved_instances: If Reserved instances exist, Ocean will utilize them before launching Spot instances.
:param pulumi.Input[Sequence[pulumi.Input[str]]] whitelists: Instance types allowed in the Ocean cluster. Cannot be configured if `blacklist` is configured.
"""
- OceanArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- security_groups=security_groups,
- subnet_ids=subnet_ids,
- associate_ipv6_address=associate_ipv6_address,
- associate_public_ip_address=associate_public_ip_address,
- autoscaler=autoscaler,
- blacklists=blacklists,
- block_device_mappings=block_device_mappings,
- cluster_orientations=cluster_orientations,
- controller_id=controller_id,
- desired_capacity=desired_capacity,
- draining_timeout=draining_timeout,
- ebs_optimized=ebs_optimized,
- fallback_to_ondemand=fallback_to_ondemand,
- filters=filters,
- grace_period=grace_period,
- iam_instance_profile=iam_instance_profile,
- image_id=image_id,
- instance_metadata_options=instance_metadata_options,
- key_name=key_name,
- load_balancers=load_balancers,
- logging=logging,
- max_size=max_size,
- min_size=min_size,
- monitoring=monitoring,
- name=name,
- region=region,
- resource_tag_specifications=resource_tag_specifications,
- root_volume_size=root_volume_size,
- scheduled_tasks=scheduled_tasks,
- spot_percentage=spot_percentage,
- spread_nodes_by=spread_nodes_by,
- tags=tags,
- update_policy=update_policy,
- use_as_template_only=use_as_template_only,
- user_data=user_data,
- utilize_commitments=utilize_commitments,
- utilize_reserved_instances=utilize_reserved_instances,
- whitelists=whitelists,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- associate_ipv6_address: Optional[pulumi.Input[bool]] = None,
- associate_public_ip_address: Optional[pulumi.Input[bool]] = None,
- autoscaler: Optional[pulumi.Input['OceanAutoscalerArgs']] = None,
- blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- block_device_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['OceanBlockDeviceMappingArgs']]]] = None,
- cluster_orientations: Optional[pulumi.Input[Sequence[pulumi.Input['OceanClusterOrientationArgs']]]] = None,
- controller_id: Optional[pulumi.Input[str]] = None,
- desired_capacity: Optional[pulumi.Input[int]] = None,
- draining_timeout: Optional[pulumi.Input[int]] = None,
- ebs_optimized: Optional[pulumi.Input[bool]] = None,
- fallback_to_ondemand: Optional[pulumi.Input[bool]] = None,
- filters: Optional[pulumi.Input['OceanFiltersArgs']] = None,
- grace_period: Optional[pulumi.Input[int]] = None,
- iam_instance_profile: Optional[pulumi.Input[str]] = None,
- image_id: Optional[pulumi.Input[str]] = None,
- instance_metadata_options: Optional[pulumi.Input['OceanInstanceMetadataOptionsArgs']] = None,
- key_name: Optional[pulumi.Input[str]] = None,
- load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLoadBalancerArgs']]]] = None,
- logging: Optional[pulumi.Input['OceanLoggingArgs']] = None,
- max_size: Optional[pulumi.Input[int]] = None,
- min_size: Optional[pulumi.Input[int]] = None,
- monitoring: Optional[pulumi.Input[bool]] = None,
- name: Optional[pulumi.Input[str]] = None,
- region: Optional[pulumi.Input[str]] = None,
- resource_tag_specifications: Optional[pulumi.Input[Sequence[pulumi.Input['OceanResourceTagSpecificationArgs']]]] = None,
- root_volume_size: Optional[pulumi.Input[int]] = None,
- scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['OceanScheduledTaskArgs']]]] = None,
- spot_percentage: Optional[pulumi.Input[int]] = None,
- spread_nodes_by: Optional[pulumi.Input[str]] = None,
- tags: Optional[pulumi.Input[Sequence[pulumi.Input['OceanTagArgs']]]] = None,
- update_policy: Optional[pulumi.Input['OceanUpdatePolicyArgs']] = None,
- use_as_template_only: Optional[pulumi.Input[bool]] = None,
- user_data: Optional[pulumi.Input[str]] = None,
- utilize_commitments: Optional[pulumi.Input[bool]] = None,
- utilize_reserved_instances: Optional[pulumi.Input[bool]] = None,
- whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if security_groups is None and 'securityGroups' in kwargs:
- security_groups = kwargs['securityGroups']
- if security_groups is None:
- raise TypeError("Missing 'security_groups' argument")
- if subnet_ids is None and 'subnetIds' in kwargs:
- subnet_ids = kwargs['subnetIds']
- if subnet_ids is None:
- raise TypeError("Missing 'subnet_ids' argument")
- if associate_ipv6_address is None and 'associateIpv6Address' in kwargs:
- associate_ipv6_address = kwargs['associateIpv6Address']
- if associate_public_ip_address is None and 'associatePublicIpAddress' in kwargs:
- associate_public_ip_address = kwargs['associatePublicIpAddress']
- if block_device_mappings is None and 'blockDeviceMappings' in kwargs:
- block_device_mappings = kwargs['blockDeviceMappings']
- if cluster_orientations is None and 'clusterOrientations' in kwargs:
- cluster_orientations = kwargs['clusterOrientations']
- if controller_id is None and 'controllerId' in kwargs:
- controller_id = kwargs['controllerId']
- if desired_capacity is None and 'desiredCapacity' in kwargs:
- desired_capacity = kwargs['desiredCapacity']
- if draining_timeout is None and 'drainingTimeout' in kwargs:
- draining_timeout = kwargs['drainingTimeout']
- if ebs_optimized is None and 'ebsOptimized' in kwargs:
- ebs_optimized = kwargs['ebsOptimized']
- if fallback_to_ondemand is None and 'fallbackToOndemand' in kwargs:
- fallback_to_ondemand = kwargs['fallbackToOndemand']
- if grace_period is None and 'gracePeriod' in kwargs:
- grace_period = kwargs['gracePeriod']
- if iam_instance_profile is None and 'iamInstanceProfile' in kwargs:
- iam_instance_profile = kwargs['iamInstanceProfile']
- if image_id is None and 'imageId' in kwargs:
- image_id = kwargs['imageId']
- if instance_metadata_options is None and 'instanceMetadataOptions' in kwargs:
- instance_metadata_options = kwargs['instanceMetadataOptions']
- if key_name is None and 'keyName' in kwargs:
- key_name = kwargs['keyName']
- if load_balancers is None and 'loadBalancers' in kwargs:
- load_balancers = kwargs['loadBalancers']
- if max_size is None and 'maxSize' in kwargs:
- max_size = kwargs['maxSize']
- if min_size is None and 'minSize' in kwargs:
- min_size = kwargs['minSize']
- if resource_tag_specifications is None and 'resourceTagSpecifications' in kwargs:
- resource_tag_specifications = kwargs['resourceTagSpecifications']
- if root_volume_size is None and 'rootVolumeSize' in kwargs:
- root_volume_size = kwargs['rootVolumeSize']
- if scheduled_tasks is None and 'scheduledTasks' in kwargs:
- scheduled_tasks = kwargs['scheduledTasks']
- if spot_percentage is None and 'spotPercentage' in kwargs:
- spot_percentage = kwargs['spotPercentage']
- if spread_nodes_by is None and 'spreadNodesBy' in kwargs:
- spread_nodes_by = kwargs['spreadNodesBy']
- if update_policy is None and 'updatePolicy' in kwargs:
- update_policy = kwargs['updatePolicy']
- if use_as_template_only is None and 'useAsTemplateOnly' in kwargs:
- use_as_template_only = kwargs['useAsTemplateOnly']
- if user_data is None and 'userData' in kwargs:
- user_data = kwargs['userData']
- if utilize_commitments is None and 'utilizeCommitments' in kwargs:
- utilize_commitments = kwargs['utilizeCommitments']
- if utilize_reserved_instances is None and 'utilizeReservedInstances' in kwargs:
- utilize_reserved_instances = kwargs['utilizeReservedInstances']
-
- _setter("security_groups", security_groups)
- _setter("subnet_ids", subnet_ids)
+ pulumi.set(__self__, "security_groups", security_groups)
+ pulumi.set(__self__, "subnet_ids", subnet_ids)
if associate_ipv6_address is not None:
- _setter("associate_ipv6_address", associate_ipv6_address)
+ pulumi.set(__self__, "associate_ipv6_address", associate_ipv6_address)
if associate_public_ip_address is not None:
- _setter("associate_public_ip_address", associate_public_ip_address)
+ pulumi.set(__self__, "associate_public_ip_address", associate_public_ip_address)
if autoscaler is not None:
- _setter("autoscaler", autoscaler)
+ pulumi.set(__self__, "autoscaler", autoscaler)
if blacklists is not None:
- _setter("blacklists", blacklists)
+ pulumi.set(__self__, "blacklists", blacklists)
if block_device_mappings is not None:
- _setter("block_device_mappings", block_device_mappings)
+ pulumi.set(__self__, "block_device_mappings", block_device_mappings)
if cluster_orientations is not None:
- _setter("cluster_orientations", cluster_orientations)
+ pulumi.set(__self__, "cluster_orientations", cluster_orientations)
if controller_id is not None:
- _setter("controller_id", controller_id)
+ pulumi.set(__self__, "controller_id", controller_id)
if desired_capacity is not None:
- _setter("desired_capacity", desired_capacity)
+ pulumi.set(__self__, "desired_capacity", desired_capacity)
if draining_timeout is not None:
- _setter("draining_timeout", draining_timeout)
+ pulumi.set(__self__, "draining_timeout", draining_timeout)
if ebs_optimized is not None:
- _setter("ebs_optimized", ebs_optimized)
+ pulumi.set(__self__, "ebs_optimized", ebs_optimized)
if fallback_to_ondemand is not None:
- _setter("fallback_to_ondemand", fallback_to_ondemand)
+ pulumi.set(__self__, "fallback_to_ondemand", fallback_to_ondemand)
if filters is not None:
- _setter("filters", filters)
+ pulumi.set(__self__, "filters", filters)
if grace_period is not None:
- _setter("grace_period", grace_period)
+ pulumi.set(__self__, "grace_period", grace_period)
if iam_instance_profile is not None:
- _setter("iam_instance_profile", iam_instance_profile)
+ pulumi.set(__self__, "iam_instance_profile", iam_instance_profile)
if image_id is not None:
- _setter("image_id", image_id)
+ pulumi.set(__self__, "image_id", image_id)
if instance_metadata_options is not None:
- _setter("instance_metadata_options", instance_metadata_options)
+ pulumi.set(__self__, "instance_metadata_options", instance_metadata_options)
if key_name is not None:
- _setter("key_name", key_name)
+ pulumi.set(__self__, "key_name", key_name)
if load_balancers is not None:
- _setter("load_balancers", load_balancers)
+ pulumi.set(__self__, "load_balancers", load_balancers)
if logging is not None:
- _setter("logging", logging)
+ pulumi.set(__self__, "logging", logging)
if max_size is not None:
- _setter("max_size", max_size)
+ pulumi.set(__self__, "max_size", max_size)
if min_size is not None:
- _setter("min_size", min_size)
+ pulumi.set(__self__, "min_size", min_size)
if monitoring is not None:
- _setter("monitoring", monitoring)
+ pulumi.set(__self__, "monitoring", monitoring)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if region is not None:
- _setter("region", region)
+ pulumi.set(__self__, "region", region)
if resource_tag_specifications is not None:
- _setter("resource_tag_specifications", resource_tag_specifications)
+ pulumi.set(__self__, "resource_tag_specifications", resource_tag_specifications)
if root_volume_size is not None:
- _setter("root_volume_size", root_volume_size)
+ pulumi.set(__self__, "root_volume_size", root_volume_size)
if scheduled_tasks is not None:
- _setter("scheduled_tasks", scheduled_tasks)
+ pulumi.set(__self__, "scheduled_tasks", scheduled_tasks)
if spot_percentage is not None:
- _setter("spot_percentage", spot_percentage)
+ pulumi.set(__self__, "spot_percentage", spot_percentage)
if spread_nodes_by is not None:
- _setter("spread_nodes_by", spread_nodes_by)
+ pulumi.set(__self__, "spread_nodes_by", spread_nodes_by)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
if update_policy is not None:
- _setter("update_policy", update_policy)
+ pulumi.set(__self__, "update_policy", update_policy)
if use_as_template_only is not None:
- _setter("use_as_template_only", use_as_template_only)
+ pulumi.set(__self__, "use_as_template_only", use_as_template_only)
if user_data is not None:
- _setter("user_data", user_data)
+ pulumi.set(__self__, "user_data", user_data)
if utilize_commitments is not None:
- _setter("utilize_commitments", utilize_commitments)
+ pulumi.set(__self__, "utilize_commitments", utilize_commitments)
if utilize_reserved_instances is not None:
- _setter("utilize_reserved_instances", utilize_reserved_instances)
+ pulumi.set(__self__, "utilize_reserved_instances", utilize_reserved_instances)
if whitelists is not None:
- _setter("whitelists", whitelists)
+ pulumi.set(__self__, "whitelists", whitelists)
@property
@pulumi.getter(name="securityGroups")
@@ -839,225 +692,82 @@ def __init__(__self__, *,
:param pulumi.Input[bool] utilize_reserved_instances: If Reserved instances exist, Ocean will utilize them before launching Spot instances.
:param pulumi.Input[Sequence[pulumi.Input[str]]] whitelists: Instance types allowed in the Ocean cluster. Cannot be configured if `blacklist` is configured.
"""
- _OceanState._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- associate_ipv6_address=associate_ipv6_address,
- associate_public_ip_address=associate_public_ip_address,
- autoscaler=autoscaler,
- blacklists=blacklists,
- block_device_mappings=block_device_mappings,
- cluster_orientations=cluster_orientations,
- controller_id=controller_id,
- desired_capacity=desired_capacity,
- draining_timeout=draining_timeout,
- ebs_optimized=ebs_optimized,
- fallback_to_ondemand=fallback_to_ondemand,
- filters=filters,
- grace_period=grace_period,
- iam_instance_profile=iam_instance_profile,
- image_id=image_id,
- instance_metadata_options=instance_metadata_options,
- key_name=key_name,
- load_balancers=load_balancers,
- logging=logging,
- max_size=max_size,
- min_size=min_size,
- monitoring=monitoring,
- name=name,
- region=region,
- resource_tag_specifications=resource_tag_specifications,
- root_volume_size=root_volume_size,
- scheduled_tasks=scheduled_tasks,
- security_groups=security_groups,
- spot_percentage=spot_percentage,
- spread_nodes_by=spread_nodes_by,
- subnet_ids=subnet_ids,
- tags=tags,
- update_policy=update_policy,
- use_as_template_only=use_as_template_only,
- user_data=user_data,
- utilize_commitments=utilize_commitments,
- utilize_reserved_instances=utilize_reserved_instances,
- whitelists=whitelists,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- associate_ipv6_address: Optional[pulumi.Input[bool]] = None,
- associate_public_ip_address: Optional[pulumi.Input[bool]] = None,
- autoscaler: Optional[pulumi.Input['OceanAutoscalerArgs']] = None,
- blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- block_device_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['OceanBlockDeviceMappingArgs']]]] = None,
- cluster_orientations: Optional[pulumi.Input[Sequence[pulumi.Input['OceanClusterOrientationArgs']]]] = None,
- controller_id: Optional[pulumi.Input[str]] = None,
- desired_capacity: Optional[pulumi.Input[int]] = None,
- draining_timeout: Optional[pulumi.Input[int]] = None,
- ebs_optimized: Optional[pulumi.Input[bool]] = None,
- fallback_to_ondemand: Optional[pulumi.Input[bool]] = None,
- filters: Optional[pulumi.Input['OceanFiltersArgs']] = None,
- grace_period: Optional[pulumi.Input[int]] = None,
- iam_instance_profile: Optional[pulumi.Input[str]] = None,
- image_id: Optional[pulumi.Input[str]] = None,
- instance_metadata_options: Optional[pulumi.Input['OceanInstanceMetadataOptionsArgs']] = None,
- key_name: Optional[pulumi.Input[str]] = None,
- load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLoadBalancerArgs']]]] = None,
- logging: Optional[pulumi.Input['OceanLoggingArgs']] = None,
- max_size: Optional[pulumi.Input[int]] = None,
- min_size: Optional[pulumi.Input[int]] = None,
- monitoring: Optional[pulumi.Input[bool]] = None,
- name: Optional[pulumi.Input[str]] = None,
- region: Optional[pulumi.Input[str]] = None,
- resource_tag_specifications: Optional[pulumi.Input[Sequence[pulumi.Input['OceanResourceTagSpecificationArgs']]]] = None,
- root_volume_size: Optional[pulumi.Input[int]] = None,
- scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['OceanScheduledTaskArgs']]]] = None,
- security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- spot_percentage: Optional[pulumi.Input[int]] = None,
- spread_nodes_by: Optional[pulumi.Input[str]] = None,
- subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- tags: Optional[pulumi.Input[Sequence[pulumi.Input['OceanTagArgs']]]] = None,
- update_policy: Optional[pulumi.Input['OceanUpdatePolicyArgs']] = None,
- use_as_template_only: Optional[pulumi.Input[bool]] = None,
- user_data: Optional[pulumi.Input[str]] = None,
- utilize_commitments: Optional[pulumi.Input[bool]] = None,
- utilize_reserved_instances: Optional[pulumi.Input[bool]] = None,
- whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if associate_ipv6_address is None and 'associateIpv6Address' in kwargs:
- associate_ipv6_address = kwargs['associateIpv6Address']
- if associate_public_ip_address is None and 'associatePublicIpAddress' in kwargs:
- associate_public_ip_address = kwargs['associatePublicIpAddress']
- if block_device_mappings is None and 'blockDeviceMappings' in kwargs:
- block_device_mappings = kwargs['blockDeviceMappings']
- if cluster_orientations is None and 'clusterOrientations' in kwargs:
- cluster_orientations = kwargs['clusterOrientations']
- if controller_id is None and 'controllerId' in kwargs:
- controller_id = kwargs['controllerId']
- if desired_capacity is None and 'desiredCapacity' in kwargs:
- desired_capacity = kwargs['desiredCapacity']
- if draining_timeout is None and 'drainingTimeout' in kwargs:
- draining_timeout = kwargs['drainingTimeout']
- if ebs_optimized is None and 'ebsOptimized' in kwargs:
- ebs_optimized = kwargs['ebsOptimized']
- if fallback_to_ondemand is None and 'fallbackToOndemand' in kwargs:
- fallback_to_ondemand = kwargs['fallbackToOndemand']
- if grace_period is None and 'gracePeriod' in kwargs:
- grace_period = kwargs['gracePeriod']
- if iam_instance_profile is None and 'iamInstanceProfile' in kwargs:
- iam_instance_profile = kwargs['iamInstanceProfile']
- if image_id is None and 'imageId' in kwargs:
- image_id = kwargs['imageId']
- if instance_metadata_options is None and 'instanceMetadataOptions' in kwargs:
- instance_metadata_options = kwargs['instanceMetadataOptions']
- if key_name is None and 'keyName' in kwargs:
- key_name = kwargs['keyName']
- if load_balancers is None and 'loadBalancers' in kwargs:
- load_balancers = kwargs['loadBalancers']
- if max_size is None and 'maxSize' in kwargs:
- max_size = kwargs['maxSize']
- if min_size is None and 'minSize' in kwargs:
- min_size = kwargs['minSize']
- if resource_tag_specifications is None and 'resourceTagSpecifications' in kwargs:
- resource_tag_specifications = kwargs['resourceTagSpecifications']
- if root_volume_size is None and 'rootVolumeSize' in kwargs:
- root_volume_size = kwargs['rootVolumeSize']
- if scheduled_tasks is None and 'scheduledTasks' in kwargs:
- scheduled_tasks = kwargs['scheduledTasks']
- if security_groups is None and 'securityGroups' in kwargs:
- security_groups = kwargs['securityGroups']
- if spot_percentage is None and 'spotPercentage' in kwargs:
- spot_percentage = kwargs['spotPercentage']
- if spread_nodes_by is None and 'spreadNodesBy' in kwargs:
- spread_nodes_by = kwargs['spreadNodesBy']
- if subnet_ids is None and 'subnetIds' in kwargs:
- subnet_ids = kwargs['subnetIds']
- if update_policy is None and 'updatePolicy' in kwargs:
- update_policy = kwargs['updatePolicy']
- if use_as_template_only is None and 'useAsTemplateOnly' in kwargs:
- use_as_template_only = kwargs['useAsTemplateOnly']
- if user_data is None and 'userData' in kwargs:
- user_data = kwargs['userData']
- if utilize_commitments is None and 'utilizeCommitments' in kwargs:
- utilize_commitments = kwargs['utilizeCommitments']
- if utilize_reserved_instances is None and 'utilizeReservedInstances' in kwargs:
- utilize_reserved_instances = kwargs['utilizeReservedInstances']
-
if associate_ipv6_address is not None:
- _setter("associate_ipv6_address", associate_ipv6_address)
+ pulumi.set(__self__, "associate_ipv6_address", associate_ipv6_address)
if associate_public_ip_address is not None:
- _setter("associate_public_ip_address", associate_public_ip_address)
+ pulumi.set(__self__, "associate_public_ip_address", associate_public_ip_address)
if autoscaler is not None:
- _setter("autoscaler", autoscaler)
+ pulumi.set(__self__, "autoscaler", autoscaler)
if blacklists is not None:
- _setter("blacklists", blacklists)
+ pulumi.set(__self__, "blacklists", blacklists)
if block_device_mappings is not None:
- _setter("block_device_mappings", block_device_mappings)
+ pulumi.set(__self__, "block_device_mappings", block_device_mappings)
if cluster_orientations is not None:
- _setter("cluster_orientations", cluster_orientations)
+ pulumi.set(__self__, "cluster_orientations", cluster_orientations)
if controller_id is not None:
- _setter("controller_id", controller_id)
+ pulumi.set(__self__, "controller_id", controller_id)
if desired_capacity is not None:
- _setter("desired_capacity", desired_capacity)
+ pulumi.set(__self__, "desired_capacity", desired_capacity)
if draining_timeout is not None:
- _setter("draining_timeout", draining_timeout)
+ pulumi.set(__self__, "draining_timeout", draining_timeout)
if ebs_optimized is not None:
- _setter("ebs_optimized", ebs_optimized)
+ pulumi.set(__self__, "ebs_optimized", ebs_optimized)
if fallback_to_ondemand is not None:
- _setter("fallback_to_ondemand", fallback_to_ondemand)
+ pulumi.set(__self__, "fallback_to_ondemand", fallback_to_ondemand)
if filters is not None:
- _setter("filters", filters)
+ pulumi.set(__self__, "filters", filters)
if grace_period is not None:
- _setter("grace_period", grace_period)
+ pulumi.set(__self__, "grace_period", grace_period)
if iam_instance_profile is not None:
- _setter("iam_instance_profile", iam_instance_profile)
+ pulumi.set(__self__, "iam_instance_profile", iam_instance_profile)
if image_id is not None:
- _setter("image_id", image_id)
+ pulumi.set(__self__, "image_id", image_id)
if instance_metadata_options is not None:
- _setter("instance_metadata_options", instance_metadata_options)
+ pulumi.set(__self__, "instance_metadata_options", instance_metadata_options)
if key_name is not None:
- _setter("key_name", key_name)
+ pulumi.set(__self__, "key_name", key_name)
if load_balancers is not None:
- _setter("load_balancers", load_balancers)
+ pulumi.set(__self__, "load_balancers", load_balancers)
if logging is not None:
- _setter("logging", logging)
+ pulumi.set(__self__, "logging", logging)
if max_size is not None:
- _setter("max_size", max_size)
+ pulumi.set(__self__, "max_size", max_size)
if min_size is not None:
- _setter("min_size", min_size)
+ pulumi.set(__self__, "min_size", min_size)
if monitoring is not None:
- _setter("monitoring", monitoring)
+ pulumi.set(__self__, "monitoring", monitoring)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if region is not None:
- _setter("region", region)
+ pulumi.set(__self__, "region", region)
if resource_tag_specifications is not None:
- _setter("resource_tag_specifications", resource_tag_specifications)
+ pulumi.set(__self__, "resource_tag_specifications", resource_tag_specifications)
if root_volume_size is not None:
- _setter("root_volume_size", root_volume_size)
+ pulumi.set(__self__, "root_volume_size", root_volume_size)
if scheduled_tasks is not None:
- _setter("scheduled_tasks", scheduled_tasks)
+ pulumi.set(__self__, "scheduled_tasks", scheduled_tasks)
if security_groups is not None:
- _setter("security_groups", security_groups)
+ pulumi.set(__self__, "security_groups", security_groups)
if spot_percentage is not None:
- _setter("spot_percentage", spot_percentage)
+ pulumi.set(__self__, "spot_percentage", spot_percentage)
if spread_nodes_by is not None:
- _setter("spread_nodes_by", spread_nodes_by)
+ pulumi.set(__self__, "spread_nodes_by", spread_nodes_by)
if subnet_ids is not None:
- _setter("subnet_ids", subnet_ids)
+ pulumi.set(__self__, "subnet_ids", subnet_ids)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
if update_policy is not None:
- _setter("update_policy", update_policy)
+ pulumi.set(__self__, "update_policy", update_policy)
if use_as_template_only is not None:
- _setter("use_as_template_only", use_as_template_only)
+ pulumi.set(__self__, "use_as_template_only", use_as_template_only)
if user_data is not None:
- _setter("user_data", user_data)
+ pulumi.set(__self__, "user_data", user_data)
if utilize_commitments is not None:
- _setter("utilize_commitments", utilize_commitments)
+ pulumi.set(__self__, "utilize_commitments", utilize_commitments)
if utilize_reserved_instances is not None:
- _setter("utilize_reserved_instances", utilize_reserved_instances)
+ pulumi.set(__self__, "utilize_reserved_instances", utilize_reserved_instances)
if whitelists is not None:
- _setter("whitelists", whitelists)
+ pulumi.set(__self__, "whitelists", whitelists)
@property
@pulumi.getter(name="associateIpv6Address")
@@ -1735,10 +1445,6 @@ def __init__(__self__, resource_name: str, *args, **kwargs):
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
- kwargs = kwargs or {}
- def _setter(key, value):
- kwargs[key] = value
- OceanArgs._configure(_setter, **kwargs)
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
@@ -1793,7 +1499,6 @@ def _internal_init(__self__,
__props__.__dict__["associate_ipv6_address"] = associate_ipv6_address
__props__.__dict__["associate_public_ip_address"] = associate_public_ip_address
- autoscaler = _utilities.configure(autoscaler, OceanAutoscalerArgs, True)
__props__.__dict__["autoscaler"] = autoscaler
__props__.__dict__["blacklists"] = blacklists
__props__.__dict__["block_device_mappings"] = block_device_mappings
@@ -1803,16 +1508,13 @@ def _internal_init(__self__,
__props__.__dict__["draining_timeout"] = draining_timeout
__props__.__dict__["ebs_optimized"] = ebs_optimized
__props__.__dict__["fallback_to_ondemand"] = fallback_to_ondemand
- filters = _utilities.configure(filters, OceanFiltersArgs, True)
__props__.__dict__["filters"] = filters
__props__.__dict__["grace_period"] = grace_period
__props__.__dict__["iam_instance_profile"] = iam_instance_profile
__props__.__dict__["image_id"] = image_id
- instance_metadata_options = _utilities.configure(instance_metadata_options, OceanInstanceMetadataOptionsArgs, True)
__props__.__dict__["instance_metadata_options"] = instance_metadata_options
__props__.__dict__["key_name"] = key_name
__props__.__dict__["load_balancers"] = load_balancers
- logging = _utilities.configure(logging, OceanLoggingArgs, True)
__props__.__dict__["logging"] = logging
__props__.__dict__["max_size"] = max_size
__props__.__dict__["min_size"] = min_size
@@ -1831,7 +1533,6 @@ def _internal_init(__self__,
raise TypeError("Missing required property 'subnet_ids'")
__props__.__dict__["subnet_ids"] = subnet_ids
__props__.__dict__["tags"] = tags
- update_policy = _utilities.configure(update_policy, OceanUpdatePolicyArgs, True)
__props__.__dict__["update_policy"] = update_policy
__props__.__dict__["use_as_template_only"] = use_as_template_only
__props__.__dict__["user_data"] = user_data
diff --git a/sdk/python/pulumi_spotinst/aws/ocean_extended_resource_definition.py b/sdk/python/pulumi_spotinst/aws/ocean_extended_resource_definition.py
index ae20761b..84de08df 100644
--- a/sdk/python/pulumi_spotinst/aws/ocean_extended_resource_definition.py
+++ b/sdk/python/pulumi_spotinst/aws/ocean_extended_resource_definition.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
__all__ = ['OceanExtendedResourceDefinitionArgs', 'OceanExtendedResourceDefinition']
@@ -22,26 +22,9 @@ def __init__(__self__, *,
:param pulumi.Input[str] name: The extended resource name as should be requested by your pods and registered to the nodes. Cannot be updated.
The name should be a valid Kubernetes extended resource name.
"""
- OceanExtendedResourceDefinitionArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- resource_mapping=resource_mapping,
- name=name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- resource_mapping: Optional[pulumi.Input[Mapping[str, Any]]] = None,
- name: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if resource_mapping is None and 'resourceMapping' in kwargs:
- resource_mapping = kwargs['resourceMapping']
- if resource_mapping is None:
- raise TypeError("Missing 'resource_mapping' argument")
-
- _setter("resource_mapping", resource_mapping)
+ pulumi.set(__self__, "resource_mapping", resource_mapping)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
@property
@pulumi.getter(name="resourceMapping")
@@ -80,25 +63,10 @@ def __init__(__self__, *,
The name should be a valid Kubernetes extended resource name.
:param pulumi.Input[Mapping[str, Any]] resource_mapping: A mapping between AWS instanceType or * as default and its value for the given extended resource.
"""
- _OceanExtendedResourceDefinitionState._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- resource_mapping=resource_mapping,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- resource_mapping: Optional[pulumi.Input[Mapping[str, Any]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if resource_mapping is None and 'resourceMapping' in kwargs:
- resource_mapping = kwargs['resourceMapping']
-
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if resource_mapping is not None:
- _setter("resource_mapping", resource_mapping)
+ pulumi.set(__self__, "resource_mapping", resource_mapping)
@property
@pulumi.getter
@@ -186,10 +154,6 @@ def __init__(__self__, resource_name: str, *args, **kwargs):
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
- kwargs = kwargs or {}
- def _setter(key, value):
- kwargs[key] = value
- OceanExtendedResourceDefinitionArgs._configure(_setter, **kwargs)
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
diff --git a/sdk/python/pulumi_spotinst/aws/ocean_launch_spec.py b/sdk/python/pulumi_spotinst/aws/ocean_launch_spec.py
index 1a92d680..4cbae61a 100644
--- a/sdk/python/pulumi_spotinst/aws/ocean_launch_spec.py
+++ b/sdk/python/pulumi_spotinst/aws/ocean_launch_spec.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs
from ._inputs import *
@@ -76,184 +76,65 @@ def __init__(__self__, *,
:param pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecTaintArgs']]] taints: Optionally adds labels to instances launched in the cluster.
:param pulumi.Input[str] user_data: Base64-encoded MIME user data to make available to the instances.
"""
- OceanLaunchSpecArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- ocean_id=ocean_id,
- associate_public_ip_address=associate_public_ip_address,
- autoscale_downs=autoscale_downs,
- autoscale_headrooms=autoscale_headrooms,
- autoscale_headrooms_automatics=autoscale_headrooms_automatics,
- block_device_mappings=block_device_mappings,
- create_options=create_options,
- delete_options=delete_options,
- elastic_ip_pools=elastic_ip_pools,
- iam_instance_profile=iam_instance_profile,
- image_id=image_id,
- images=images,
- instance_metadata_options=instance_metadata_options,
- instance_types=instance_types,
- instance_types_filters=instance_types_filters,
- labels=labels,
- name=name,
- preferred_spot_types=preferred_spot_types,
- resource_limits=resource_limits,
- restrict_scale_down=restrict_scale_down,
- root_volume_size=root_volume_size,
- scheduling_shutdown_hours=scheduling_shutdown_hours,
- scheduling_tasks=scheduling_tasks,
- security_groups=security_groups,
- strategies=strategies,
- subnet_ids=subnet_ids,
- tags=tags,
- taints=taints,
- update_policy=update_policy,
- user_data=user_data,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- ocean_id: Optional[pulumi.Input[str]] = None,
- associate_public_ip_address: Optional[pulumi.Input[bool]] = None,
- autoscale_downs: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecAutoscaleDownArgs']]]] = None,
- autoscale_headrooms: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecAutoscaleHeadroomArgs']]]] = None,
- autoscale_headrooms_automatics: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecAutoscaleHeadroomsAutomaticArgs']]]] = None,
- block_device_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecBlockDeviceMappingArgs']]]] = None,
- create_options: Optional[pulumi.Input['OceanLaunchSpecCreateOptionsArgs']] = None,
- delete_options: Optional[pulumi.Input['OceanLaunchSpecDeleteOptionsArgs']] = None,
- elastic_ip_pools: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecElasticIpPoolArgs']]]] = None,
- iam_instance_profile: Optional[pulumi.Input[str]] = None,
- image_id: Optional[pulumi.Input[str]] = None,
- images: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecImageArgs']]]] = None,
- instance_metadata_options: Optional[pulumi.Input['OceanLaunchSpecInstanceMetadataOptionsArgs']] = None,
- instance_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- instance_types_filters: Optional[pulumi.Input['OceanLaunchSpecInstanceTypesFiltersArgs']] = None,
- labels: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecLabelArgs']]]] = None,
- name: Optional[pulumi.Input[str]] = None,
- preferred_spot_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- resource_limits: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecResourceLimitArgs']]]] = None,
- restrict_scale_down: Optional[pulumi.Input[bool]] = None,
- root_volume_size: Optional[pulumi.Input[int]] = None,
- scheduling_shutdown_hours: Optional[pulumi.Input['OceanLaunchSpecSchedulingShutdownHoursArgs']] = None,
- scheduling_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecSchedulingTaskArgs']]]] = None,
- security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- strategies: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecStrategyArgs']]]] = None,
- subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- tags: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecTagArgs']]]] = None,
- taints: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecTaintArgs']]]] = None,
- update_policy: Optional[pulumi.Input['OceanLaunchSpecUpdatePolicyArgs']] = None,
- user_data: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if ocean_id is None and 'oceanId' in kwargs:
- ocean_id = kwargs['oceanId']
- if ocean_id is None:
- raise TypeError("Missing 'ocean_id' argument")
- if associate_public_ip_address is None and 'associatePublicIpAddress' in kwargs:
- associate_public_ip_address = kwargs['associatePublicIpAddress']
- if autoscale_downs is None and 'autoscaleDowns' in kwargs:
- autoscale_downs = kwargs['autoscaleDowns']
- if autoscale_headrooms is None and 'autoscaleHeadrooms' in kwargs:
- autoscale_headrooms = kwargs['autoscaleHeadrooms']
- if autoscale_headrooms_automatics is None and 'autoscaleHeadroomsAutomatics' in kwargs:
- autoscale_headrooms_automatics = kwargs['autoscaleHeadroomsAutomatics']
- if block_device_mappings is None and 'blockDeviceMappings' in kwargs:
- block_device_mappings = kwargs['blockDeviceMappings']
- if create_options is None and 'createOptions' in kwargs:
- create_options = kwargs['createOptions']
- if delete_options is None and 'deleteOptions' in kwargs:
- delete_options = kwargs['deleteOptions']
- if elastic_ip_pools is None and 'elasticIpPools' in kwargs:
- elastic_ip_pools = kwargs['elasticIpPools']
- if iam_instance_profile is None and 'iamInstanceProfile' in kwargs:
- iam_instance_profile = kwargs['iamInstanceProfile']
- if image_id is None and 'imageId' in kwargs:
- image_id = kwargs['imageId']
- if instance_metadata_options is None and 'instanceMetadataOptions' in kwargs:
- instance_metadata_options = kwargs['instanceMetadataOptions']
- if instance_types is None and 'instanceTypes' in kwargs:
- instance_types = kwargs['instanceTypes']
- if instance_types_filters is None and 'instanceTypesFilters' in kwargs:
- instance_types_filters = kwargs['instanceTypesFilters']
- if preferred_spot_types is None and 'preferredSpotTypes' in kwargs:
- preferred_spot_types = kwargs['preferredSpotTypes']
- if resource_limits is None and 'resourceLimits' in kwargs:
- resource_limits = kwargs['resourceLimits']
- if restrict_scale_down is None and 'restrictScaleDown' in kwargs:
- restrict_scale_down = kwargs['restrictScaleDown']
- if root_volume_size is None and 'rootVolumeSize' in kwargs:
- root_volume_size = kwargs['rootVolumeSize']
- if scheduling_shutdown_hours is None and 'schedulingShutdownHours' in kwargs:
- scheduling_shutdown_hours = kwargs['schedulingShutdownHours']
- if scheduling_tasks is None and 'schedulingTasks' in kwargs:
- scheduling_tasks = kwargs['schedulingTasks']
- if security_groups is None and 'securityGroups' in kwargs:
- security_groups = kwargs['securityGroups']
- if subnet_ids is None and 'subnetIds' in kwargs:
- subnet_ids = kwargs['subnetIds']
- if update_policy is None and 'updatePolicy' in kwargs:
- update_policy = kwargs['updatePolicy']
- if user_data is None and 'userData' in kwargs:
- user_data = kwargs['userData']
-
- _setter("ocean_id", ocean_id)
+ pulumi.set(__self__, "ocean_id", ocean_id)
if associate_public_ip_address is not None:
- _setter("associate_public_ip_address", associate_public_ip_address)
+ pulumi.set(__self__, "associate_public_ip_address", associate_public_ip_address)
if autoscale_downs is not None:
- _setter("autoscale_downs", autoscale_downs)
+ pulumi.set(__self__, "autoscale_downs", autoscale_downs)
if autoscale_headrooms is not None:
- _setter("autoscale_headrooms", autoscale_headrooms)
+ pulumi.set(__self__, "autoscale_headrooms", autoscale_headrooms)
if autoscale_headrooms_automatics is not None:
- _setter("autoscale_headrooms_automatics", autoscale_headrooms_automatics)
+ pulumi.set(__self__, "autoscale_headrooms_automatics", autoscale_headrooms_automatics)
if block_device_mappings is not None:
- _setter("block_device_mappings", block_device_mappings)
+ pulumi.set(__self__, "block_device_mappings", block_device_mappings)
if create_options is not None:
- _setter("create_options", create_options)
+ pulumi.set(__self__, "create_options", create_options)
if delete_options is not None:
- _setter("delete_options", delete_options)
+ pulumi.set(__self__, "delete_options", delete_options)
if elastic_ip_pools is not None:
- _setter("elastic_ip_pools", elastic_ip_pools)
+ pulumi.set(__self__, "elastic_ip_pools", elastic_ip_pools)
if iam_instance_profile is not None:
- _setter("iam_instance_profile", iam_instance_profile)
+ pulumi.set(__self__, "iam_instance_profile", iam_instance_profile)
if image_id is not None:
- _setter("image_id", image_id)
+ pulumi.set(__self__, "image_id", image_id)
if images is not None:
- _setter("images", images)
+ pulumi.set(__self__, "images", images)
if instance_metadata_options is not None:
- _setter("instance_metadata_options", instance_metadata_options)
+ pulumi.set(__self__, "instance_metadata_options", instance_metadata_options)
if instance_types is not None:
- _setter("instance_types", instance_types)
+ pulumi.set(__self__, "instance_types", instance_types)
if instance_types_filters is not None:
- _setter("instance_types_filters", instance_types_filters)
+ pulumi.set(__self__, "instance_types_filters", instance_types_filters)
if labels is not None:
- _setter("labels", labels)
+ pulumi.set(__self__, "labels", labels)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if preferred_spot_types is not None:
- _setter("preferred_spot_types", preferred_spot_types)
+ pulumi.set(__self__, "preferred_spot_types", preferred_spot_types)
if resource_limits is not None:
- _setter("resource_limits", resource_limits)
+ pulumi.set(__self__, "resource_limits", resource_limits)
if restrict_scale_down is not None:
- _setter("restrict_scale_down", restrict_scale_down)
+ pulumi.set(__self__, "restrict_scale_down", restrict_scale_down)
if root_volume_size is not None:
- _setter("root_volume_size", root_volume_size)
+ pulumi.set(__self__, "root_volume_size", root_volume_size)
if scheduling_shutdown_hours is not None:
- _setter("scheduling_shutdown_hours", scheduling_shutdown_hours)
+ pulumi.set(__self__, "scheduling_shutdown_hours", scheduling_shutdown_hours)
if scheduling_tasks is not None:
- _setter("scheduling_tasks", scheduling_tasks)
+ pulumi.set(__self__, "scheduling_tasks", scheduling_tasks)
if security_groups is not None:
- _setter("security_groups", security_groups)
+ pulumi.set(__self__, "security_groups", security_groups)
if strategies is not None:
- _setter("strategies", strategies)
+ pulumi.set(__self__, "strategies", strategies)
if subnet_ids is not None:
- _setter("subnet_ids", subnet_ids)
+ pulumi.set(__self__, "subnet_ids", subnet_ids)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
if taints is not None:
- _setter("taints", taints)
+ pulumi.set(__self__, "taints", taints)
if update_policy is not None:
- _setter("update_policy", update_policy)
+ pulumi.set(__self__, "update_policy", update_policy)
if user_data is not None:
- _setter("user_data", user_data)
+ pulumi.set(__self__, "user_data", user_data)
@property
@pulumi.getter(name="oceanId")
@@ -666,183 +547,66 @@ def __init__(__self__, *,
:param pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecTaintArgs']]] taints: Optionally adds labels to instances launched in the cluster.
:param pulumi.Input[str] user_data: Base64-encoded MIME user data to make available to the instances.
"""
- _OceanLaunchSpecState._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- associate_public_ip_address=associate_public_ip_address,
- autoscale_downs=autoscale_downs,
- autoscale_headrooms=autoscale_headrooms,
- autoscale_headrooms_automatics=autoscale_headrooms_automatics,
- block_device_mappings=block_device_mappings,
- create_options=create_options,
- delete_options=delete_options,
- elastic_ip_pools=elastic_ip_pools,
- iam_instance_profile=iam_instance_profile,
- image_id=image_id,
- images=images,
- instance_metadata_options=instance_metadata_options,
- instance_types=instance_types,
- instance_types_filters=instance_types_filters,
- labels=labels,
- name=name,
- ocean_id=ocean_id,
- preferred_spot_types=preferred_spot_types,
- resource_limits=resource_limits,
- restrict_scale_down=restrict_scale_down,
- root_volume_size=root_volume_size,
- scheduling_shutdown_hours=scheduling_shutdown_hours,
- scheduling_tasks=scheduling_tasks,
- security_groups=security_groups,
- strategies=strategies,
- subnet_ids=subnet_ids,
- tags=tags,
- taints=taints,
- update_policy=update_policy,
- user_data=user_data,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- associate_public_ip_address: Optional[pulumi.Input[bool]] = None,
- autoscale_downs: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecAutoscaleDownArgs']]]] = None,
- autoscale_headrooms: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecAutoscaleHeadroomArgs']]]] = None,
- autoscale_headrooms_automatics: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecAutoscaleHeadroomsAutomaticArgs']]]] = None,
- block_device_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecBlockDeviceMappingArgs']]]] = None,
- create_options: Optional[pulumi.Input['OceanLaunchSpecCreateOptionsArgs']] = None,
- delete_options: Optional[pulumi.Input['OceanLaunchSpecDeleteOptionsArgs']] = None,
- elastic_ip_pools: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecElasticIpPoolArgs']]]] = None,
- iam_instance_profile: Optional[pulumi.Input[str]] = None,
- image_id: Optional[pulumi.Input[str]] = None,
- images: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecImageArgs']]]] = None,
- instance_metadata_options: Optional[pulumi.Input['OceanLaunchSpecInstanceMetadataOptionsArgs']] = None,
- instance_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- instance_types_filters: Optional[pulumi.Input['OceanLaunchSpecInstanceTypesFiltersArgs']] = None,
- labels: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecLabelArgs']]]] = None,
- name: Optional[pulumi.Input[str]] = None,
- ocean_id: Optional[pulumi.Input[str]] = None,
- preferred_spot_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- resource_limits: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecResourceLimitArgs']]]] = None,
- restrict_scale_down: Optional[pulumi.Input[bool]] = None,
- root_volume_size: Optional[pulumi.Input[int]] = None,
- scheduling_shutdown_hours: Optional[pulumi.Input['OceanLaunchSpecSchedulingShutdownHoursArgs']] = None,
- scheduling_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecSchedulingTaskArgs']]]] = None,
- security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- strategies: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecStrategyArgs']]]] = None,
- subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- tags: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecTagArgs']]]] = None,
- taints: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecTaintArgs']]]] = None,
- update_policy: Optional[pulumi.Input['OceanLaunchSpecUpdatePolicyArgs']] = None,
- user_data: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if associate_public_ip_address is None and 'associatePublicIpAddress' in kwargs:
- associate_public_ip_address = kwargs['associatePublicIpAddress']
- if autoscale_downs is None and 'autoscaleDowns' in kwargs:
- autoscale_downs = kwargs['autoscaleDowns']
- if autoscale_headrooms is None and 'autoscaleHeadrooms' in kwargs:
- autoscale_headrooms = kwargs['autoscaleHeadrooms']
- if autoscale_headrooms_automatics is None and 'autoscaleHeadroomsAutomatics' in kwargs:
- autoscale_headrooms_automatics = kwargs['autoscaleHeadroomsAutomatics']
- if block_device_mappings is None and 'blockDeviceMappings' in kwargs:
- block_device_mappings = kwargs['blockDeviceMappings']
- if create_options is None and 'createOptions' in kwargs:
- create_options = kwargs['createOptions']
- if delete_options is None and 'deleteOptions' in kwargs:
- delete_options = kwargs['deleteOptions']
- if elastic_ip_pools is None and 'elasticIpPools' in kwargs:
- elastic_ip_pools = kwargs['elasticIpPools']
- if iam_instance_profile is None and 'iamInstanceProfile' in kwargs:
- iam_instance_profile = kwargs['iamInstanceProfile']
- if image_id is None and 'imageId' in kwargs:
- image_id = kwargs['imageId']
- if instance_metadata_options is None and 'instanceMetadataOptions' in kwargs:
- instance_metadata_options = kwargs['instanceMetadataOptions']
- if instance_types is None and 'instanceTypes' in kwargs:
- instance_types = kwargs['instanceTypes']
- if instance_types_filters is None and 'instanceTypesFilters' in kwargs:
- instance_types_filters = kwargs['instanceTypesFilters']
- if ocean_id is None and 'oceanId' in kwargs:
- ocean_id = kwargs['oceanId']
- if preferred_spot_types is None and 'preferredSpotTypes' in kwargs:
- preferred_spot_types = kwargs['preferredSpotTypes']
- if resource_limits is None and 'resourceLimits' in kwargs:
- resource_limits = kwargs['resourceLimits']
- if restrict_scale_down is None and 'restrictScaleDown' in kwargs:
- restrict_scale_down = kwargs['restrictScaleDown']
- if root_volume_size is None and 'rootVolumeSize' in kwargs:
- root_volume_size = kwargs['rootVolumeSize']
- if scheduling_shutdown_hours is None and 'schedulingShutdownHours' in kwargs:
- scheduling_shutdown_hours = kwargs['schedulingShutdownHours']
- if scheduling_tasks is None and 'schedulingTasks' in kwargs:
- scheduling_tasks = kwargs['schedulingTasks']
- if security_groups is None and 'securityGroups' in kwargs:
- security_groups = kwargs['securityGroups']
- if subnet_ids is None and 'subnetIds' in kwargs:
- subnet_ids = kwargs['subnetIds']
- if update_policy is None and 'updatePolicy' in kwargs:
- update_policy = kwargs['updatePolicy']
- if user_data is None and 'userData' in kwargs:
- user_data = kwargs['userData']
-
if associate_public_ip_address is not None:
- _setter("associate_public_ip_address", associate_public_ip_address)
+ pulumi.set(__self__, "associate_public_ip_address", associate_public_ip_address)
if autoscale_downs is not None:
- _setter("autoscale_downs", autoscale_downs)
+ pulumi.set(__self__, "autoscale_downs", autoscale_downs)
if autoscale_headrooms is not None:
- _setter("autoscale_headrooms", autoscale_headrooms)
+ pulumi.set(__self__, "autoscale_headrooms", autoscale_headrooms)
if autoscale_headrooms_automatics is not None:
- _setter("autoscale_headrooms_automatics", autoscale_headrooms_automatics)
+ pulumi.set(__self__, "autoscale_headrooms_automatics", autoscale_headrooms_automatics)
if block_device_mappings is not None:
- _setter("block_device_mappings", block_device_mappings)
+ pulumi.set(__self__, "block_device_mappings", block_device_mappings)
if create_options is not None:
- _setter("create_options", create_options)
+ pulumi.set(__self__, "create_options", create_options)
if delete_options is not None:
- _setter("delete_options", delete_options)
+ pulumi.set(__self__, "delete_options", delete_options)
if elastic_ip_pools is not None:
- _setter("elastic_ip_pools", elastic_ip_pools)
+ pulumi.set(__self__, "elastic_ip_pools", elastic_ip_pools)
if iam_instance_profile is not None:
- _setter("iam_instance_profile", iam_instance_profile)
+ pulumi.set(__self__, "iam_instance_profile", iam_instance_profile)
if image_id is not None:
- _setter("image_id", image_id)
+ pulumi.set(__self__, "image_id", image_id)
if images is not None:
- _setter("images", images)
+ pulumi.set(__self__, "images", images)
if instance_metadata_options is not None:
- _setter("instance_metadata_options", instance_metadata_options)
+ pulumi.set(__self__, "instance_metadata_options", instance_metadata_options)
if instance_types is not None:
- _setter("instance_types", instance_types)
+ pulumi.set(__self__, "instance_types", instance_types)
if instance_types_filters is not None:
- _setter("instance_types_filters", instance_types_filters)
+ pulumi.set(__self__, "instance_types_filters", instance_types_filters)
if labels is not None:
- _setter("labels", labels)
+ pulumi.set(__self__, "labels", labels)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if ocean_id is not None:
- _setter("ocean_id", ocean_id)
+ pulumi.set(__self__, "ocean_id", ocean_id)
if preferred_spot_types is not None:
- _setter("preferred_spot_types", preferred_spot_types)
+ pulumi.set(__self__, "preferred_spot_types", preferred_spot_types)
if resource_limits is not None:
- _setter("resource_limits", resource_limits)
+ pulumi.set(__self__, "resource_limits", resource_limits)
if restrict_scale_down is not None:
- _setter("restrict_scale_down", restrict_scale_down)
+ pulumi.set(__self__, "restrict_scale_down", restrict_scale_down)
if root_volume_size is not None:
- _setter("root_volume_size", root_volume_size)
+ pulumi.set(__self__, "root_volume_size", root_volume_size)
if scheduling_shutdown_hours is not None:
- _setter("scheduling_shutdown_hours", scheduling_shutdown_hours)
+ pulumi.set(__self__, "scheduling_shutdown_hours", scheduling_shutdown_hours)
if scheduling_tasks is not None:
- _setter("scheduling_tasks", scheduling_tasks)
+ pulumi.set(__self__, "scheduling_tasks", scheduling_tasks)
if security_groups is not None:
- _setter("security_groups", security_groups)
+ pulumi.set(__self__, "security_groups", security_groups)
if strategies is not None:
- _setter("strategies", strategies)
+ pulumi.set(__self__, "strategies", strategies)
if subnet_ids is not None:
- _setter("subnet_ids", subnet_ids)
+ pulumi.set(__self__, "subnet_ids", subnet_ids)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
if taints is not None:
- _setter("taints", taints)
+ pulumi.set(__self__, "taints", taints)
if update_policy is not None:
- _setter("update_policy", update_policy)
+ pulumi.set(__self__, "update_policy", update_policy)
if user_data is not None:
- _setter("user_data", user_data)
+ pulumi.set(__self__, "user_data", user_data)
@property
@pulumi.getter(name="associatePublicIpAddress")
@@ -1546,10 +1310,6 @@ def __init__(__self__, resource_name: str, *args, **kwargs):
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
- kwargs = kwargs or {}
- def _setter(key, value):
- kwargs[key] = value
- OceanLaunchSpecArgs._configure(_setter, **kwargs)
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
@@ -1599,18 +1359,14 @@ def _internal_init(__self__,
__props__.__dict__["autoscale_headrooms"] = autoscale_headrooms
__props__.__dict__["autoscale_headrooms_automatics"] = autoscale_headrooms_automatics
__props__.__dict__["block_device_mappings"] = block_device_mappings
- create_options = _utilities.configure(create_options, OceanLaunchSpecCreateOptionsArgs, True)
__props__.__dict__["create_options"] = create_options
- delete_options = _utilities.configure(delete_options, OceanLaunchSpecDeleteOptionsArgs, True)
__props__.__dict__["delete_options"] = delete_options
__props__.__dict__["elastic_ip_pools"] = elastic_ip_pools
__props__.__dict__["iam_instance_profile"] = iam_instance_profile
__props__.__dict__["image_id"] = image_id
__props__.__dict__["images"] = images
- instance_metadata_options = _utilities.configure(instance_metadata_options, OceanLaunchSpecInstanceMetadataOptionsArgs, True)
__props__.__dict__["instance_metadata_options"] = instance_metadata_options
__props__.__dict__["instance_types"] = instance_types
- instance_types_filters = _utilities.configure(instance_types_filters, OceanLaunchSpecInstanceTypesFiltersArgs, True)
__props__.__dict__["instance_types_filters"] = instance_types_filters
__props__.__dict__["labels"] = labels
__props__.__dict__["name"] = name
@@ -1621,7 +1377,6 @@ def _internal_init(__self__,
__props__.__dict__["resource_limits"] = resource_limits
__props__.__dict__["restrict_scale_down"] = restrict_scale_down
__props__.__dict__["root_volume_size"] = root_volume_size
- scheduling_shutdown_hours = _utilities.configure(scheduling_shutdown_hours, OceanLaunchSpecSchedulingShutdownHoursArgs, True)
__props__.__dict__["scheduling_shutdown_hours"] = scheduling_shutdown_hours
__props__.__dict__["scheduling_tasks"] = scheduling_tasks
__props__.__dict__["security_groups"] = security_groups
@@ -1629,7 +1384,6 @@ def _internal_init(__self__,
__props__.__dict__["subnet_ids"] = subnet_ids
__props__.__dict__["tags"] = tags
__props__.__dict__["taints"] = taints
- update_policy = _utilities.configure(update_policy, OceanLaunchSpecUpdatePolicyArgs, True)
__props__.__dict__["update_policy"] = update_policy
__props__.__dict__["user_data"] = user_data
super(OceanLaunchSpec, __self__).__init__(
diff --git a/sdk/python/pulumi_spotinst/aws/outputs.py b/sdk/python/pulumi_spotinst/aws/outputs.py
index d1298d62..7e11fc87 100644
--- a/sdk/python/pulumi_spotinst/aws/outputs.py
+++ b/sdk/python/pulumi_spotinst/aws/outputs.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs
@@ -203,37 +203,14 @@ def __init__(__self__, *,
:param int grace_period: Amount of time to wait between batches
:param Sequence['BeanstalkDeploymentPreferencesStrategyArgs'] strategies: Strategy parameters
"""
- BeanstalkDeploymentPreferences._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- automatic_roll=automatic_roll,
- batch_size_percentage=batch_size_percentage,
- grace_period=grace_period,
- strategies=strategies,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- automatic_roll: Optional[bool] = None,
- batch_size_percentage: Optional[int] = None,
- grace_period: Optional[int] = None,
- strategies: Optional[Sequence['outputs.BeanstalkDeploymentPreferencesStrategy']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if automatic_roll is None and 'automaticRoll' in kwargs:
- automatic_roll = kwargs['automaticRoll']
- if batch_size_percentage is None and 'batchSizePercentage' in kwargs:
- batch_size_percentage = kwargs['batchSizePercentage']
- if grace_period is None and 'gracePeriod' in kwargs:
- grace_period = kwargs['gracePeriod']
-
if automatic_roll is not None:
- _setter("automatic_roll", automatic_roll)
+ pulumi.set(__self__, "automatic_roll", automatic_roll)
if batch_size_percentage is not None:
- _setter("batch_size_percentage", batch_size_percentage)
+ pulumi.set(__self__, "batch_size_percentage", batch_size_percentage)
if grace_period is not None:
- _setter("grace_period", grace_period)
+ pulumi.set(__self__, "grace_period", grace_period)
if strategies is not None:
- _setter("strategies", strategies)
+ pulumi.set(__self__, "strategies", strategies)
@property
@pulumi.getter(name="automaticRoll")
@@ -294,25 +271,10 @@ def __init__(__self__, *,
:param str action: Action to take
:param bool should_drain_instances: Bool value if to wait to drain instance
"""
- BeanstalkDeploymentPreferencesStrategy._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- action=action,
- should_drain_instances=should_drain_instances,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- action: Optional[str] = None,
- should_drain_instances: Optional[bool] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if should_drain_instances is None and 'shouldDrainInstances' in kwargs:
- should_drain_instances = kwargs['shouldDrainInstances']
-
if action is not None:
- _setter("action", action)
+ pulumi.set(__self__, "action", action)
if should_drain_instances is not None:
- _setter("should_drain_instances", should_drain_instances)
+ pulumi.set(__self__, "should_drain_instances", should_drain_instances)
@property
@pulumi.getter
@@ -355,21 +317,8 @@ def __init__(__self__, *,
"""
:param 'BeanstalkManagedActionsPlatformUpdateArgs' platform_update: Platform Update parameters
"""
- BeanstalkManagedActions._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- platform_update=platform_update,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- platform_update: Optional['outputs.BeanstalkManagedActionsPlatformUpdate'] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if platform_update is None and 'platformUpdate' in kwargs:
- platform_update = kwargs['platformUpdate']
-
if platform_update is not None:
- _setter("platform_update", platform_update)
+ pulumi.set(__self__, "platform_update", platform_update)
@property
@pulumi.getter(name="platformUpdate")
@@ -412,33 +361,12 @@ def __init__(__self__, *,
:param str time_window: Time Window for when action occurs ex. Mon:23:50-Tue:00:20
:param str update_level: Level to update
"""
- BeanstalkManagedActionsPlatformUpdate._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- perform_at=perform_at,
- time_window=time_window,
- update_level=update_level,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- perform_at: Optional[str] = None,
- time_window: Optional[str] = None,
- update_level: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if perform_at is None and 'performAt' in kwargs:
- perform_at = kwargs['performAt']
- if time_window is None and 'timeWindow' in kwargs:
- time_window = kwargs['timeWindow']
- if update_level is None and 'updateLevel' in kwargs:
- update_level = kwargs['updateLevel']
-
if perform_at is not None:
- _setter("perform_at", perform_at)
+ pulumi.set(__self__, "perform_at", perform_at)
if time_window is not None:
- _setter("time_window", time_window)
+ pulumi.set(__self__, "time_window", time_window)
if update_level is not None:
- _setter("update_level", update_level)
+ pulumi.set(__self__, "update_level", update_level)
@property
@pulumi.getter(name="performAt")
@@ -547,102 +475,35 @@ def __init__(__self__, *,
:param str start_time: Set a start time for one time tasks.
:param str target_capacity: The desired number of instances the group should have.
"""
- BeanstalkScheduledTask._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- task_type=task_type,
- adjustment=adjustment,
- adjustment_percentage=adjustment_percentage,
- batch_size_percentage=batch_size_percentage,
- cron_expression=cron_expression,
- frequency=frequency,
- grace_period=grace_period,
- is_enabled=is_enabled,
- max_capacity=max_capacity,
- min_capacity=min_capacity,
- scale_max_capacity=scale_max_capacity,
- scale_min_capacity=scale_min_capacity,
- scale_target_capacity=scale_target_capacity,
- start_time=start_time,
- target_capacity=target_capacity,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- task_type: Optional[str] = None,
- adjustment: Optional[str] = None,
- adjustment_percentage: Optional[str] = None,
- batch_size_percentage: Optional[str] = None,
- cron_expression: Optional[str] = None,
- frequency: Optional[str] = None,
- grace_period: Optional[str] = None,
- is_enabled: Optional[bool] = None,
- max_capacity: Optional[str] = None,
- min_capacity: Optional[str] = None,
- scale_max_capacity: Optional[str] = None,
- scale_min_capacity: Optional[str] = None,
- scale_target_capacity: Optional[str] = None,
- start_time: Optional[str] = None,
- target_capacity: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if task_type is None and 'taskType' in kwargs:
- task_type = kwargs['taskType']
- if task_type is None:
- raise TypeError("Missing 'task_type' argument")
- if adjustment_percentage is None and 'adjustmentPercentage' in kwargs:
- adjustment_percentage = kwargs['adjustmentPercentage']
- if batch_size_percentage is None and 'batchSizePercentage' in kwargs:
- batch_size_percentage = kwargs['batchSizePercentage']
- if cron_expression is None and 'cronExpression' in kwargs:
- cron_expression = kwargs['cronExpression']
- if grace_period is None and 'gracePeriod' in kwargs:
- grace_period = kwargs['gracePeriod']
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
- if max_capacity is None and 'maxCapacity' in kwargs:
- max_capacity = kwargs['maxCapacity']
- if min_capacity is None and 'minCapacity' in kwargs:
- min_capacity = kwargs['minCapacity']
- if scale_max_capacity is None and 'scaleMaxCapacity' in kwargs:
- scale_max_capacity = kwargs['scaleMaxCapacity']
- if scale_min_capacity is None and 'scaleMinCapacity' in kwargs:
- scale_min_capacity = kwargs['scaleMinCapacity']
- if scale_target_capacity is None and 'scaleTargetCapacity' in kwargs:
- scale_target_capacity = kwargs['scaleTargetCapacity']
- if start_time is None and 'startTime' in kwargs:
- start_time = kwargs['startTime']
- if target_capacity is None and 'targetCapacity' in kwargs:
- target_capacity = kwargs['targetCapacity']
-
- _setter("task_type", task_type)
+ pulumi.set(__self__, "task_type", task_type)
if adjustment is not None:
- _setter("adjustment", adjustment)
+ pulumi.set(__self__, "adjustment", adjustment)
if adjustment_percentage is not None:
- _setter("adjustment_percentage", adjustment_percentage)
+ pulumi.set(__self__, "adjustment_percentage", adjustment_percentage)
if batch_size_percentage is not None:
- _setter("batch_size_percentage", batch_size_percentage)
+ pulumi.set(__self__, "batch_size_percentage", batch_size_percentage)
if cron_expression is not None:
- _setter("cron_expression", cron_expression)
+ pulumi.set(__self__, "cron_expression", cron_expression)
if frequency is not None:
- _setter("frequency", frequency)
+ pulumi.set(__self__, "frequency", frequency)
if grace_period is not None:
- _setter("grace_period", grace_period)
+ pulumi.set(__self__, "grace_period", grace_period)
if is_enabled is not None:
- _setter("is_enabled", is_enabled)
+ pulumi.set(__self__, "is_enabled", is_enabled)
if max_capacity is not None:
- _setter("max_capacity", max_capacity)
+ pulumi.set(__self__, "max_capacity", max_capacity)
if min_capacity is not None:
- _setter("min_capacity", min_capacity)
+ pulumi.set(__self__, "min_capacity", min_capacity)
if scale_max_capacity is not None:
- _setter("scale_max_capacity", scale_max_capacity)
+ pulumi.set(__self__, "scale_max_capacity", scale_max_capacity)
if scale_min_capacity is not None:
- _setter("scale_min_capacity", scale_min_capacity)
+ pulumi.set(__self__, "scale_min_capacity", scale_min_capacity)
if scale_target_capacity is not None:
- _setter("scale_target_capacity", scale_target_capacity)
+ pulumi.set(__self__, "scale_target_capacity", scale_target_capacity)
if start_time is not None:
- _setter("start_time", start_time)
+ pulumi.set(__self__, "start_time", start_time)
if target_capacity is not None:
- _setter("target_capacity", target_capacity)
+ pulumi.set(__self__, "target_capacity", target_capacity)
@property
@pulumi.getter(name="taskType")
@@ -795,22 +656,7 @@ def __init__(__self__, *,
"""
:param int threads_per_core: The ability to define the number of threads per core in instances that allow this.
"""
- ElastigroupCpuOptions._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- threads_per_core=threads_per_core,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- threads_per_core: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if threads_per_core is None and 'threadsPerCore' in kwargs:
- threads_per_core = kwargs['threadsPerCore']
- if threads_per_core is None:
- raise TypeError("Missing 'threads_per_core' argument")
-
- _setter("threads_per_core", threads_per_core)
+ pulumi.set(__self__, "threads_per_core", threads_per_core)
@property
@pulumi.getter(name="threadsPerCore")
@@ -879,64 +725,23 @@ def __init__(__self__, *,
:param int volume_size: The size of the volume in gigabytes.
:param str volume_type: The type of volume. Can be `"standard"`, `"gp2"`, `"gp3"`, `"io1"`, `"st1"` or `"sc1"`.
"""
- ElastigroupEbsBlockDevice._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- device_name=device_name,
- delete_on_termination=delete_on_termination,
- encrypted=encrypted,
- iops=iops,
- kms_key_id=kms_key_id,
- snapshot_id=snapshot_id,
- throughput=throughput,
- volume_size=volume_size,
- volume_type=volume_type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- device_name: Optional[str] = None,
- delete_on_termination: Optional[bool] = None,
- encrypted: Optional[bool] = None,
- iops: Optional[int] = None,
- kms_key_id: Optional[str] = None,
- snapshot_id: Optional[str] = None,
- throughput: Optional[int] = None,
- volume_size: Optional[int] = None,
- volume_type: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if device_name is None and 'deviceName' in kwargs:
- device_name = kwargs['deviceName']
- if device_name is None:
- raise TypeError("Missing 'device_name' argument")
- if delete_on_termination is None and 'deleteOnTermination' in kwargs:
- delete_on_termination = kwargs['deleteOnTermination']
- if kms_key_id is None and 'kmsKeyId' in kwargs:
- kms_key_id = kwargs['kmsKeyId']
- if snapshot_id is None and 'snapshotId' in kwargs:
- snapshot_id = kwargs['snapshotId']
- if volume_size is None and 'volumeSize' in kwargs:
- volume_size = kwargs['volumeSize']
- if volume_type is None and 'volumeType' in kwargs:
- volume_type = kwargs['volumeType']
-
- _setter("device_name", device_name)
+ pulumi.set(__self__, "device_name", device_name)
if delete_on_termination is not None:
- _setter("delete_on_termination", delete_on_termination)
+ pulumi.set(__self__, "delete_on_termination", delete_on_termination)
if encrypted is not None:
- _setter("encrypted", encrypted)
+ pulumi.set(__self__, "encrypted", encrypted)
if iops is not None:
- _setter("iops", iops)
+ pulumi.set(__self__, "iops", iops)
if kms_key_id is not None:
- _setter("kms_key_id", kms_key_id)
+ pulumi.set(__self__, "kms_key_id", kms_key_id)
if snapshot_id is not None:
- _setter("snapshot_id", snapshot_id)
+ pulumi.set(__self__, "snapshot_id", snapshot_id)
if throughput is not None:
- _setter("throughput", throughput)
+ pulumi.set(__self__, "throughput", throughput)
if volume_size is not None:
- _setter("volume_size", volume_size)
+ pulumi.set(__self__, "volume_size", volume_size)
if volume_type is not None:
- _setter("volume_type", volume_type)
+ pulumi.set(__self__, "volume_type", volume_type)
@property
@pulumi.getter(name="deviceName")
@@ -1054,29 +859,8 @@ def __init__(__self__, *,
import pulumi
```
"""
- ElastigroupEphemeralBlockDevice._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- device_name=device_name,
- virtual_name=virtual_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- device_name: Optional[str] = None,
- virtual_name: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if device_name is None and 'deviceName' in kwargs:
- device_name = kwargs['deviceName']
- if device_name is None:
- raise TypeError("Missing 'device_name' argument")
- if virtual_name is None and 'virtualName' in kwargs:
- virtual_name = kwargs['virtualName']
- if virtual_name is None:
- raise TypeError("Missing 'virtual_name' argument")
-
- _setter("device_name", device_name)
- _setter("virtual_name", virtual_name)
+ pulumi.set(__self__, "device_name", device_name)
+ pulumi.set(__self__, "virtual_name", virtual_name)
@property
@pulumi.getter(name="deviceName")
@@ -1106,20 +890,7 @@ def virtual_name(self) -> str:
class ElastigroupImage(dict):
def __init__(__self__, *,
images: Sequence['outputs.ElastigroupImageImage']):
- ElastigroupImage._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- images=images,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- images: Optional[Sequence['outputs.ElastigroupImageImage']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if images is None:
- raise TypeError("Missing 'images' argument")
-
- _setter("images", images)
+ pulumi.set(__self__, "images", images)
@property
@pulumi.getter
@@ -1134,20 +905,7 @@ def __init__(__self__, *,
"""
:param str id: The group ID.
"""
- ElastigroupImageImage._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- id=id,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- id: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if id is None:
- raise TypeError("Missing 'id' argument")
-
- _setter("id", id)
+ pulumi.set(__self__, "id", id)
@property
@pulumi.getter
@@ -1184,27 +942,8 @@ def __init__(__self__, *,
:param str instance_type: Name of instance type (String).
:param int weight: Weight per instance type (Integer).
"""
- ElastigroupInstanceTypesWeight._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- instance_type=instance_type,
- weight=weight,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- instance_type: Optional[str] = None,
- weight: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if instance_type is None and 'instanceType' in kwargs:
- instance_type = kwargs['instanceType']
- if instance_type is None:
- raise TypeError("Missing 'instance_type' argument")
- if weight is None:
- raise TypeError("Missing 'weight' argument")
-
- _setter("instance_type", instance_type)
- _setter("weight", weight)
+ pulumi.set(__self__, "instance_type", instance_type)
+ pulumi.set(__self__, "weight", weight)
@property
@pulumi.getter(name="instanceType")
@@ -1254,33 +993,12 @@ def __init__(__self__, *,
:param 'ElastigroupIntegrationBeanstalkDeploymentPreferencesArgs' deployment_preferences: Preferences when performing a roll
:param 'ElastigroupIntegrationBeanstalkManagedActionsArgs' managed_actions: Managed Actions parameters
"""
- ElastigroupIntegrationBeanstalk._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- deployment_preferences=deployment_preferences,
- environment_id=environment_id,
- managed_actions=managed_actions,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- deployment_preferences: Optional['outputs.ElastigroupIntegrationBeanstalkDeploymentPreferences'] = None,
- environment_id: Optional[str] = None,
- managed_actions: Optional['outputs.ElastigroupIntegrationBeanstalkManagedActions'] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if deployment_preferences is None and 'deploymentPreferences' in kwargs:
- deployment_preferences = kwargs['deploymentPreferences']
- if environment_id is None and 'environmentId' in kwargs:
- environment_id = kwargs['environmentId']
- if managed_actions is None and 'managedActions' in kwargs:
- managed_actions = kwargs['managedActions']
-
if deployment_preferences is not None:
- _setter("deployment_preferences", deployment_preferences)
+ pulumi.set(__self__, "deployment_preferences", deployment_preferences)
if environment_id is not None:
- _setter("environment_id", environment_id)
+ pulumi.set(__self__, "environment_id", environment_id)
if managed_actions is not None:
- _setter("managed_actions", managed_actions)
+ pulumi.set(__self__, "managed_actions", managed_actions)
@property
@pulumi.getter(name="deploymentPreferences")
@@ -1338,37 +1056,14 @@ def __init__(__self__, *,
:param int grace_period: The period of time (seconds) to wait before checking a batch's health after it's deployment.
:param 'ElastigroupIntegrationBeanstalkDeploymentPreferencesStrategyArgs' strategy: Strategy parameters
"""
- ElastigroupIntegrationBeanstalkDeploymentPreferences._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- automatic_roll=automatic_roll,
- batch_size_percentage=batch_size_percentage,
- grace_period=grace_period,
- strategy=strategy,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- automatic_roll: Optional[bool] = None,
- batch_size_percentage: Optional[int] = None,
- grace_period: Optional[int] = None,
- strategy: Optional['outputs.ElastigroupIntegrationBeanstalkDeploymentPreferencesStrategy'] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if automatic_roll is None and 'automaticRoll' in kwargs:
- automatic_roll = kwargs['automaticRoll']
- if batch_size_percentage is None and 'batchSizePercentage' in kwargs:
- batch_size_percentage = kwargs['batchSizePercentage']
- if grace_period is None and 'gracePeriod' in kwargs:
- grace_period = kwargs['gracePeriod']
-
if automatic_roll is not None:
- _setter("automatic_roll", automatic_roll)
+ pulumi.set(__self__, "automatic_roll", automatic_roll)
if batch_size_percentage is not None:
- _setter("batch_size_percentage", batch_size_percentage)
+ pulumi.set(__self__, "batch_size_percentage", batch_size_percentage)
if grace_period is not None:
- _setter("grace_period", grace_period)
+ pulumi.set(__self__, "grace_period", grace_period)
if strategy is not None:
- _setter("strategy", strategy)
+ pulumi.set(__self__, "strategy", strategy)
@property
@pulumi.getter(name="automaticRoll")
@@ -1429,25 +1124,10 @@ def __init__(__self__, *,
:param str action: The action to take when scale up according to step's threshold is needed.
:param bool should_drain_instances: Bool value if to wait to drain instance
"""
- ElastigroupIntegrationBeanstalkDeploymentPreferencesStrategy._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- action=action,
- should_drain_instances=should_drain_instances,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- action: Optional[str] = None,
- should_drain_instances: Optional[bool] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if should_drain_instances is None and 'shouldDrainInstances' in kwargs:
- should_drain_instances = kwargs['shouldDrainInstances']
-
if action is not None:
- _setter("action", action)
+ pulumi.set(__self__, "action", action)
if should_drain_instances is not None:
- _setter("should_drain_instances", should_drain_instances)
+ pulumi.set(__self__, "should_drain_instances", should_drain_instances)
@property
@pulumi.getter
@@ -1490,21 +1170,8 @@ def __init__(__self__, *,
"""
:param 'ElastigroupIntegrationBeanstalkManagedActionsPlatformUpdateArgs' platform_update: Platform Update parameters
"""
- ElastigroupIntegrationBeanstalkManagedActions._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- platform_update=platform_update,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- platform_update: Optional['outputs.ElastigroupIntegrationBeanstalkManagedActionsPlatformUpdate'] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if platform_update is None and 'platformUpdate' in kwargs:
- platform_update = kwargs['platformUpdate']
-
if platform_update is not None:
- _setter("platform_update", platform_update)
+ pulumi.set(__self__, "platform_update", platform_update)
@property
@pulumi.getter(name="platformUpdate")
@@ -1553,33 +1220,12 @@ def __init__(__self__, *,
import pulumi
```
"""
- ElastigroupIntegrationBeanstalkManagedActionsPlatformUpdate._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- perform_at=perform_at,
- time_window=time_window,
- update_level=update_level,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- perform_at: Optional[str] = None,
- time_window: Optional[str] = None,
- update_level: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if perform_at is None and 'performAt' in kwargs:
- perform_at = kwargs['performAt']
- if time_window is None and 'timeWindow' in kwargs:
- time_window = kwargs['timeWindow']
- if update_level is None and 'updateLevel' in kwargs:
- update_level = kwargs['updateLevel']
-
if perform_at is not None:
- _setter("perform_at", perform_at)
+ pulumi.set(__self__, "perform_at", perform_at)
if time_window is not None:
- _setter("time_window", time_window)
+ pulumi.set(__self__, "time_window", time_window)
if update_level is not None:
- _setter("update_level", update_level)
+ pulumi.set(__self__, "update_level", update_level)
@property
@pulumi.getter(name="performAt")
@@ -1644,36 +1290,9 @@ def __init__(__self__, *,
:param Sequence['ElastigroupIntegrationCodedeployDeploymentGroupArgs'] deployment_groups: Specify the deployment groups details.
:param bool terminate_instance_on_failure: Terminate the instance automatically after a failed deploy.
"""
- ElastigroupIntegrationCodedeploy._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cleanup_on_failure=cleanup_on_failure,
- deployment_groups=deployment_groups,
- terminate_instance_on_failure=terminate_instance_on_failure,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cleanup_on_failure: Optional[bool] = None,
- deployment_groups: Optional[Sequence['outputs.ElastigroupIntegrationCodedeployDeploymentGroup']] = None,
- terminate_instance_on_failure: Optional[bool] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cleanup_on_failure is None and 'cleanupOnFailure' in kwargs:
- cleanup_on_failure = kwargs['cleanupOnFailure']
- if cleanup_on_failure is None:
- raise TypeError("Missing 'cleanup_on_failure' argument")
- if deployment_groups is None and 'deploymentGroups' in kwargs:
- deployment_groups = kwargs['deploymentGroups']
- if deployment_groups is None:
- raise TypeError("Missing 'deployment_groups' argument")
- if terminate_instance_on_failure is None and 'terminateInstanceOnFailure' in kwargs:
- terminate_instance_on_failure = kwargs['terminateInstanceOnFailure']
- if terminate_instance_on_failure is None:
- raise TypeError("Missing 'terminate_instance_on_failure' argument")
-
- _setter("cleanup_on_failure", cleanup_on_failure)
- _setter("deployment_groups", deployment_groups)
- _setter("terminate_instance_on_failure", terminate_instance_on_failure)
+ pulumi.set(__self__, "cleanup_on_failure", cleanup_on_failure)
+ pulumi.set(__self__, "deployment_groups", deployment_groups)
+ pulumi.set(__self__, "terminate_instance_on_failure", terminate_instance_on_failure)
@property
@pulumi.getter(name="cleanupOnFailure")
@@ -1734,29 +1353,8 @@ def __init__(__self__, *,
import pulumi
```
"""
- ElastigroupIntegrationCodedeployDeploymentGroup._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- application_name=application_name,
- deployment_group_name=deployment_group_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- application_name: Optional[str] = None,
- deployment_group_name: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if application_name is None and 'applicationName' in kwargs:
- application_name = kwargs['applicationName']
- if application_name is None:
- raise TypeError("Missing 'application_name' argument")
- if deployment_group_name is None and 'deploymentGroupName' in kwargs:
- deployment_group_name = kwargs['deploymentGroupName']
- if deployment_group_name is None:
- raise TypeError("Missing 'deployment_group_name' argument")
-
- _setter("application_name", application_name)
- _setter("deployment_group_name", deployment_group_name)
+ pulumi.set(__self__, "application_name", application_name)
+ pulumi.set(__self__, "deployment_group_name", deployment_group_name)
@property
@pulumi.getter(name="applicationName")
@@ -1825,53 +1423,16 @@ def __init__(__self__, *,
:param 'ElastigroupIntegrationDockerSwarmAutoscaleHeadroomArgs' autoscale_headroom: An option to set compute reserve for the cluster.
:param bool autoscale_is_enabled: Specifies whether the auto scaling feature is enabled.
"""
- ElastigroupIntegrationDockerSwarm._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- master_host=master_host,
- master_port=master_port,
- autoscale_cooldown=autoscale_cooldown,
- autoscale_down=autoscale_down,
- autoscale_headroom=autoscale_headroom,
- autoscale_is_enabled=autoscale_is_enabled,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- master_host: Optional[str] = None,
- master_port: Optional[int] = None,
- autoscale_cooldown: Optional[int] = None,
- autoscale_down: Optional['outputs.ElastigroupIntegrationDockerSwarmAutoscaleDown'] = None,
- autoscale_headroom: Optional['outputs.ElastigroupIntegrationDockerSwarmAutoscaleHeadroom'] = None,
- autoscale_is_enabled: Optional[bool] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if master_host is None and 'masterHost' in kwargs:
- master_host = kwargs['masterHost']
- if master_host is None:
- raise TypeError("Missing 'master_host' argument")
- if master_port is None and 'masterPort' in kwargs:
- master_port = kwargs['masterPort']
- if master_port is None:
- raise TypeError("Missing 'master_port' argument")
- if autoscale_cooldown is None and 'autoscaleCooldown' in kwargs:
- autoscale_cooldown = kwargs['autoscaleCooldown']
- if autoscale_down is None and 'autoscaleDown' in kwargs:
- autoscale_down = kwargs['autoscaleDown']
- if autoscale_headroom is None and 'autoscaleHeadroom' in kwargs:
- autoscale_headroom = kwargs['autoscaleHeadroom']
- if autoscale_is_enabled is None and 'autoscaleIsEnabled' in kwargs:
- autoscale_is_enabled = kwargs['autoscaleIsEnabled']
-
- _setter("master_host", master_host)
- _setter("master_port", master_port)
+ pulumi.set(__self__, "master_host", master_host)
+ pulumi.set(__self__, "master_port", master_port)
if autoscale_cooldown is not None:
- _setter("autoscale_cooldown", autoscale_cooldown)
+ pulumi.set(__self__, "autoscale_cooldown", autoscale_cooldown)
if autoscale_down is not None:
- _setter("autoscale_down", autoscale_down)
+ pulumi.set(__self__, "autoscale_down", autoscale_down)
if autoscale_headroom is not None:
- _setter("autoscale_headroom", autoscale_headroom)
+ pulumi.set(__self__, "autoscale_headroom", autoscale_headroom)
if autoscale_is_enabled is not None:
- _setter("autoscale_is_enabled", autoscale_is_enabled)
+ pulumi.set(__self__, "autoscale_is_enabled", autoscale_is_enabled)
@property
@pulumi.getter(name="masterHost")
@@ -1950,27 +1511,10 @@ def __init__(__self__, *,
:param int evaluation_periods: The number of periods over which data is compared to the specified threshold.
:param float max_scale_down_percentage: Represents the maximum percent to scale-down. Number between 1-100.
"""
- ElastigroupIntegrationDockerSwarmAutoscaleDown._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- evaluation_periods=evaluation_periods,
- max_scale_down_percentage=max_scale_down_percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- evaluation_periods: Optional[int] = None,
- max_scale_down_percentage: Optional[float] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
- if max_scale_down_percentage is None and 'maxScaleDownPercentage' in kwargs:
- max_scale_down_percentage = kwargs['maxScaleDownPercentage']
-
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
if max_scale_down_percentage is not None:
- _setter("max_scale_down_percentage", max_scale_down_percentage)
+ pulumi.set(__self__, "max_scale_down_percentage", max_scale_down_percentage)
@property
@pulumi.getter(name="evaluationPeriods")
@@ -2021,33 +1565,12 @@ def __init__(__self__, *,
:param int memory_per_unit: How much Memory allocate for headroom unit.
:param int num_of_units: How many units of headroom to allocate.
"""
- ElastigroupIntegrationDockerSwarmAutoscaleHeadroom._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cpu_per_unit=cpu_per_unit,
- memory_per_unit=memory_per_unit,
- num_of_units=num_of_units,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cpu_per_unit: Optional[int] = None,
- memory_per_unit: Optional[int] = None,
- num_of_units: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cpu_per_unit is None and 'cpuPerUnit' in kwargs:
- cpu_per_unit = kwargs['cpuPerUnit']
- if memory_per_unit is None and 'memoryPerUnit' in kwargs:
- memory_per_unit = kwargs['memoryPerUnit']
- if num_of_units is None and 'numOfUnits' in kwargs:
- num_of_units = kwargs['numOfUnits']
-
if cpu_per_unit is not None:
- _setter("cpu_per_unit", cpu_per_unit)
+ pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
if memory_per_unit is not None:
- _setter("memory_per_unit", memory_per_unit)
+ pulumi.set(__self__, "memory_per_unit", memory_per_unit)
if num_of_units is not None:
- _setter("num_of_units", num_of_units)
+ pulumi.set(__self__, "num_of_units", num_of_units)
@property
@pulumi.getter(name="cpuPerUnit")
@@ -2128,68 +1651,23 @@ def __init__(__self__, *,
:param bool autoscale_scale_down_non_service_tasks: Determines whether to scale down non-service tasks.
:param 'ElastigroupIntegrationEcsBatchArgs' batch: Batch configuration object:
"""
- ElastigroupIntegrationEcs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cluster_name=cluster_name,
- autoscale_attributes=autoscale_attributes,
- autoscale_cooldown=autoscale_cooldown,
- autoscale_down=autoscale_down,
- autoscale_headroom=autoscale_headroom,
- autoscale_is_auto_config=autoscale_is_auto_config,
- autoscale_is_enabled=autoscale_is_enabled,
- autoscale_scale_down_non_service_tasks=autoscale_scale_down_non_service_tasks,
- batch=batch,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cluster_name: Optional[str] = None,
- autoscale_attributes: Optional[Sequence['outputs.ElastigroupIntegrationEcsAutoscaleAttribute']] = None,
- autoscale_cooldown: Optional[int] = None,
- autoscale_down: Optional['outputs.ElastigroupIntegrationEcsAutoscaleDown'] = None,
- autoscale_headroom: Optional['outputs.ElastigroupIntegrationEcsAutoscaleHeadroom'] = None,
- autoscale_is_auto_config: Optional[bool] = None,
- autoscale_is_enabled: Optional[bool] = None,
- autoscale_scale_down_non_service_tasks: Optional[bool] = None,
- batch: Optional['outputs.ElastigroupIntegrationEcsBatch'] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cluster_name is None and 'clusterName' in kwargs:
- cluster_name = kwargs['clusterName']
- if cluster_name is None:
- raise TypeError("Missing 'cluster_name' argument")
- if autoscale_attributes is None and 'autoscaleAttributes' in kwargs:
- autoscale_attributes = kwargs['autoscaleAttributes']
- if autoscale_cooldown is None and 'autoscaleCooldown' in kwargs:
- autoscale_cooldown = kwargs['autoscaleCooldown']
- if autoscale_down is None and 'autoscaleDown' in kwargs:
- autoscale_down = kwargs['autoscaleDown']
- if autoscale_headroom is None and 'autoscaleHeadroom' in kwargs:
- autoscale_headroom = kwargs['autoscaleHeadroom']
- if autoscale_is_auto_config is None and 'autoscaleIsAutoConfig' in kwargs:
- autoscale_is_auto_config = kwargs['autoscaleIsAutoConfig']
- if autoscale_is_enabled is None and 'autoscaleIsEnabled' in kwargs:
- autoscale_is_enabled = kwargs['autoscaleIsEnabled']
- if autoscale_scale_down_non_service_tasks is None and 'autoscaleScaleDownNonServiceTasks' in kwargs:
- autoscale_scale_down_non_service_tasks = kwargs['autoscaleScaleDownNonServiceTasks']
-
- _setter("cluster_name", cluster_name)
+ pulumi.set(__self__, "cluster_name", cluster_name)
if autoscale_attributes is not None:
- _setter("autoscale_attributes", autoscale_attributes)
+ pulumi.set(__self__, "autoscale_attributes", autoscale_attributes)
if autoscale_cooldown is not None:
- _setter("autoscale_cooldown", autoscale_cooldown)
+ pulumi.set(__self__, "autoscale_cooldown", autoscale_cooldown)
if autoscale_down is not None:
- _setter("autoscale_down", autoscale_down)
+ pulumi.set(__self__, "autoscale_down", autoscale_down)
if autoscale_headroom is not None:
- _setter("autoscale_headroom", autoscale_headroom)
+ pulumi.set(__self__, "autoscale_headroom", autoscale_headroom)
if autoscale_is_auto_config is not None:
- _setter("autoscale_is_auto_config", autoscale_is_auto_config)
+ pulumi.set(__self__, "autoscale_is_auto_config", autoscale_is_auto_config)
if autoscale_is_enabled is not None:
- _setter("autoscale_is_enabled", autoscale_is_enabled)
+ pulumi.set(__self__, "autoscale_is_enabled", autoscale_is_enabled)
if autoscale_scale_down_non_service_tasks is not None:
- _setter("autoscale_scale_down_non_service_tasks", autoscale_scale_down_non_service_tasks)
+ pulumi.set(__self__, "autoscale_scale_down_non_service_tasks", autoscale_scale_down_non_service_tasks)
if batch is not None:
- _setter("batch", batch)
+ pulumi.set(__self__, "batch", batch)
@property
@pulumi.getter(name="clusterName")
@@ -2272,25 +1750,8 @@ def __init__(__self__, *,
"""
:param str value: The dimension value.
"""
- ElastigroupIntegrationEcsAutoscaleAttribute._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -2334,27 +1795,10 @@ def __init__(__self__, *,
:param int evaluation_periods: The number of periods over which data is compared to the specified threshold.
:param float max_scale_down_percentage: Represents the maximum percent to scale-down. Number between 1-100.
"""
- ElastigroupIntegrationEcsAutoscaleDown._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- evaluation_periods=evaluation_periods,
- max_scale_down_percentage=max_scale_down_percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- evaluation_periods: Optional[int] = None,
- max_scale_down_percentage: Optional[float] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
- if max_scale_down_percentage is None and 'maxScaleDownPercentage' in kwargs:
- max_scale_down_percentage = kwargs['maxScaleDownPercentage']
-
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
if max_scale_down_percentage is not None:
- _setter("max_scale_down_percentage", max_scale_down_percentage)
+ pulumi.set(__self__, "max_scale_down_percentage", max_scale_down_percentage)
@property
@pulumi.getter(name="evaluationPeriods")
@@ -2405,33 +1849,12 @@ def __init__(__self__, *,
:param int memory_per_unit: How much Memory allocate for headroom unit.
:param int num_of_units: How many units of headroom to allocate.
"""
- ElastigroupIntegrationEcsAutoscaleHeadroom._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cpu_per_unit=cpu_per_unit,
- memory_per_unit=memory_per_unit,
- num_of_units=num_of_units,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cpu_per_unit: Optional[int] = None,
- memory_per_unit: Optional[int] = None,
- num_of_units: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cpu_per_unit is None and 'cpuPerUnit' in kwargs:
- cpu_per_unit = kwargs['cpuPerUnit']
- if memory_per_unit is None and 'memoryPerUnit' in kwargs:
- memory_per_unit = kwargs['memoryPerUnit']
- if num_of_units is None and 'numOfUnits' in kwargs:
- num_of_units = kwargs['numOfUnits']
-
if cpu_per_unit is not None:
- _setter("cpu_per_unit", cpu_per_unit)
+ pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
if memory_per_unit is not None:
- _setter("memory_per_unit", memory_per_unit)
+ pulumi.set(__self__, "memory_per_unit", memory_per_unit)
if num_of_units is not None:
- _setter("num_of_units", num_of_units)
+ pulumi.set(__self__, "num_of_units", num_of_units)
@property
@pulumi.getter(name="cpuPerUnit")
@@ -2488,22 +1911,7 @@ def __init__(__self__, *,
import pulumi
```
"""
- ElastigroupIntegrationEcsBatch._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- job_queue_names=job_queue_names,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- job_queue_names: Optional[Sequence[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if job_queue_names is None and 'jobQueueNames' in kwargs:
- job_queue_names = kwargs['jobQueueNames']
- if job_queue_names is None:
- raise TypeError("Missing 'job_queue_names' argument")
-
- _setter("job_queue_names", job_queue_names)
+ pulumi.set(__self__, "job_queue_names", job_queue_names)
@property
@pulumi.getter(name="jobQueueNames")
@@ -2527,19 +1935,8 @@ def __init__(__self__, *,
"""
:param 'ElastigroupIntegrationGitlabRunnerArgs' runner: Settings for Gitlab runner.
"""
- ElastigroupIntegrationGitlab._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- runner=runner,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- runner: Optional['outputs.ElastigroupIntegrationGitlabRunner'] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if runner is not None:
- _setter("runner", runner)
+ pulumi.set(__self__, "runner", runner)
@property
@pulumi.getter
@@ -2574,21 +1971,8 @@ def __init__(__self__, *,
"""
:param bool is_enabled: Specifies whether the scaling policy described in this block is enabled.
"""
- ElastigroupIntegrationGitlabRunner._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- is_enabled=is_enabled,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- is_enabled: Optional[bool] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
-
if is_enabled is not None:
- _setter("is_enabled", is_enabled)
+ pulumi.set(__self__, "is_enabled", is_enabled)
@property
@pulumi.getter(name="isEnabled")
@@ -2668,73 +2052,26 @@ def __init__(__self__, *,
:param str integration_mode: Valid values: `"saas"`, `"pod"`.
:param str token: Kubernetes Token
"""
- ElastigroupIntegrationKubernetes._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- api_server=api_server,
- autoscale_cooldown=autoscale_cooldown,
- autoscale_down=autoscale_down,
- autoscale_headroom=autoscale_headroom,
- autoscale_is_auto_config=autoscale_is_auto_config,
- autoscale_is_enabled=autoscale_is_enabled,
- autoscale_labels=autoscale_labels,
- cluster_identifier=cluster_identifier,
- integration_mode=integration_mode,
- token=token,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- api_server: Optional[str] = None,
- autoscale_cooldown: Optional[int] = None,
- autoscale_down: Optional['outputs.ElastigroupIntegrationKubernetesAutoscaleDown'] = None,
- autoscale_headroom: Optional['outputs.ElastigroupIntegrationKubernetesAutoscaleHeadroom'] = None,
- autoscale_is_auto_config: Optional[bool] = None,
- autoscale_is_enabled: Optional[bool] = None,
- autoscale_labels: Optional[Sequence['outputs.ElastigroupIntegrationKubernetesAutoscaleLabel']] = None,
- cluster_identifier: Optional[str] = None,
- integration_mode: Optional[str] = None,
- token: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if api_server is None and 'apiServer' in kwargs:
- api_server = kwargs['apiServer']
- if autoscale_cooldown is None and 'autoscaleCooldown' in kwargs:
- autoscale_cooldown = kwargs['autoscaleCooldown']
- if autoscale_down is None and 'autoscaleDown' in kwargs:
- autoscale_down = kwargs['autoscaleDown']
- if autoscale_headroom is None and 'autoscaleHeadroom' in kwargs:
- autoscale_headroom = kwargs['autoscaleHeadroom']
- if autoscale_is_auto_config is None and 'autoscaleIsAutoConfig' in kwargs:
- autoscale_is_auto_config = kwargs['autoscaleIsAutoConfig']
- if autoscale_is_enabled is None and 'autoscaleIsEnabled' in kwargs:
- autoscale_is_enabled = kwargs['autoscaleIsEnabled']
- if autoscale_labels is None and 'autoscaleLabels' in kwargs:
- autoscale_labels = kwargs['autoscaleLabels']
- if cluster_identifier is None and 'clusterIdentifier' in kwargs:
- cluster_identifier = kwargs['clusterIdentifier']
- if integration_mode is None and 'integrationMode' in kwargs:
- integration_mode = kwargs['integrationMode']
-
if api_server is not None:
- _setter("api_server", api_server)
+ pulumi.set(__self__, "api_server", api_server)
if autoscale_cooldown is not None:
- _setter("autoscale_cooldown", autoscale_cooldown)
+ pulumi.set(__self__, "autoscale_cooldown", autoscale_cooldown)
if autoscale_down is not None:
- _setter("autoscale_down", autoscale_down)
+ pulumi.set(__self__, "autoscale_down", autoscale_down)
if autoscale_headroom is not None:
- _setter("autoscale_headroom", autoscale_headroom)
+ pulumi.set(__self__, "autoscale_headroom", autoscale_headroom)
if autoscale_is_auto_config is not None:
- _setter("autoscale_is_auto_config", autoscale_is_auto_config)
+ pulumi.set(__self__, "autoscale_is_auto_config", autoscale_is_auto_config)
if autoscale_is_enabled is not None:
- _setter("autoscale_is_enabled", autoscale_is_enabled)
+ pulumi.set(__self__, "autoscale_is_enabled", autoscale_is_enabled)
if autoscale_labels is not None:
- _setter("autoscale_labels", autoscale_labels)
+ pulumi.set(__self__, "autoscale_labels", autoscale_labels)
if cluster_identifier is not None:
- _setter("cluster_identifier", cluster_identifier)
+ pulumi.set(__self__, "cluster_identifier", cluster_identifier)
if integration_mode is not None:
- _setter("integration_mode", integration_mode)
+ pulumi.set(__self__, "integration_mode", integration_mode)
if token is not None:
- _setter("token", token)
+ pulumi.set(__self__, "token", token)
@property
@pulumi.getter(name="apiServer")
@@ -2854,27 +2191,10 @@ def __init__(__self__, *,
:param int evaluation_periods: The number of periods over which data is compared to the specified threshold.
:param float max_scale_down_percentage: Represents the maximum percent to scale-down. Number between 1-100.
"""
- ElastigroupIntegrationKubernetesAutoscaleDown._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- evaluation_periods=evaluation_periods,
- max_scale_down_percentage=max_scale_down_percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- evaluation_periods: Optional[int] = None,
- max_scale_down_percentage: Optional[float] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
- if max_scale_down_percentage is None and 'maxScaleDownPercentage' in kwargs:
- max_scale_down_percentage = kwargs['maxScaleDownPercentage']
-
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
if max_scale_down_percentage is not None:
- _setter("max_scale_down_percentage", max_scale_down_percentage)
+ pulumi.set(__self__, "max_scale_down_percentage", max_scale_down_percentage)
@property
@pulumi.getter(name="evaluationPeriods")
@@ -2925,33 +2245,12 @@ def __init__(__self__, *,
:param int memory_per_unit: How much Memory allocate for headroom unit.
:param int num_of_units: How many units of headroom to allocate.
"""
- ElastigroupIntegrationKubernetesAutoscaleHeadroom._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cpu_per_unit=cpu_per_unit,
- memory_per_unit=memory_per_unit,
- num_of_units=num_of_units,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cpu_per_unit: Optional[int] = None,
- memory_per_unit: Optional[int] = None,
- num_of_units: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cpu_per_unit is None and 'cpuPerUnit' in kwargs:
- cpu_per_unit = kwargs['cpuPerUnit']
- if memory_per_unit is None and 'memoryPerUnit' in kwargs:
- memory_per_unit = kwargs['memoryPerUnit']
- if num_of_units is None and 'numOfUnits' in kwargs:
- num_of_units = kwargs['numOfUnits']
-
if cpu_per_unit is not None:
- _setter("cpu_per_unit", cpu_per_unit)
+ pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
if memory_per_unit is not None:
- _setter("memory_per_unit", memory_per_unit)
+ pulumi.set(__self__, "memory_per_unit", memory_per_unit)
if num_of_units is not None:
- _setter("num_of_units", num_of_units)
+ pulumi.set(__self__, "num_of_units", num_of_units)
@property
@pulumi.getter(name="cpuPerUnit")
@@ -2986,25 +2285,8 @@ def __init__(__self__, *,
"""
:param str value: The dimension value.
"""
- ElastigroupIntegrationKubernetesAutoscaleLabel._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -3050,22 +2332,7 @@ def __init__(__self__, *,
import pulumi
```
"""
- ElastigroupIntegrationMesosphere._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- api_server=api_server,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- api_server: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if api_server is None and 'apiServer' in kwargs:
- api_server = kwargs['apiServer']
- if api_server is None:
- raise TypeError("Missing 'api_server' argument")
-
- _setter("api_server", api_server)
+ pulumi.set(__self__, "api_server", api_server)
@property
@pulumi.getter(name="apiServer")
@@ -3112,22 +2379,7 @@ def __init__(__self__, *,
import pulumi
```
"""
- ElastigroupIntegrationMultaiRuntime._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- deployment_id=deployment_id,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- deployment_id: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if deployment_id is None and 'deploymentId' in kwargs:
- deployment_id = kwargs['deploymentId']
- if deployment_id is None:
- raise TypeError("Missing 'deployment_id' argument")
-
- _setter("deployment_id", deployment_id)
+ pulumi.set(__self__, "deployment_id", deployment_id)
@property
@pulumi.getter(name="deploymentId")
@@ -3202,65 +2454,20 @@ def __init__(__self__, *,
:param 'ElastigroupIntegrationNomadAutoscaleHeadroomArgs' autoscale_headroom: An option to set compute reserve for the cluster.
:param bool autoscale_is_enabled: Specifies whether the auto scaling feature is enabled.
"""
- ElastigroupIntegrationNomad._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- master_host=master_host,
- master_port=master_port,
- acl_token=acl_token,
- autoscale_constraints=autoscale_constraints,
- autoscale_cooldown=autoscale_cooldown,
- autoscale_down=autoscale_down,
- autoscale_headroom=autoscale_headroom,
- autoscale_is_enabled=autoscale_is_enabled,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- master_host: Optional[str] = None,
- master_port: Optional[int] = None,
- acl_token: Optional[str] = None,
- autoscale_constraints: Optional[Sequence['outputs.ElastigroupIntegrationNomadAutoscaleConstraint']] = None,
- autoscale_cooldown: Optional[int] = None,
- autoscale_down: Optional['outputs.ElastigroupIntegrationNomadAutoscaleDown'] = None,
- autoscale_headroom: Optional['outputs.ElastigroupIntegrationNomadAutoscaleHeadroom'] = None,
- autoscale_is_enabled: Optional[bool] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if master_host is None and 'masterHost' in kwargs:
- master_host = kwargs['masterHost']
- if master_host is None:
- raise TypeError("Missing 'master_host' argument")
- if master_port is None and 'masterPort' in kwargs:
- master_port = kwargs['masterPort']
- if master_port is None:
- raise TypeError("Missing 'master_port' argument")
- if acl_token is None and 'aclToken' in kwargs:
- acl_token = kwargs['aclToken']
- if autoscale_constraints is None and 'autoscaleConstraints' in kwargs:
- autoscale_constraints = kwargs['autoscaleConstraints']
- if autoscale_cooldown is None and 'autoscaleCooldown' in kwargs:
- autoscale_cooldown = kwargs['autoscaleCooldown']
- if autoscale_down is None and 'autoscaleDown' in kwargs:
- autoscale_down = kwargs['autoscaleDown']
- if autoscale_headroom is None and 'autoscaleHeadroom' in kwargs:
- autoscale_headroom = kwargs['autoscaleHeadroom']
- if autoscale_is_enabled is None and 'autoscaleIsEnabled' in kwargs:
- autoscale_is_enabled = kwargs['autoscaleIsEnabled']
-
- _setter("master_host", master_host)
- _setter("master_port", master_port)
+ pulumi.set(__self__, "master_host", master_host)
+ pulumi.set(__self__, "master_port", master_port)
if acl_token is not None:
- _setter("acl_token", acl_token)
+ pulumi.set(__self__, "acl_token", acl_token)
if autoscale_constraints is not None:
- _setter("autoscale_constraints", autoscale_constraints)
+ pulumi.set(__self__, "autoscale_constraints", autoscale_constraints)
if autoscale_cooldown is not None:
- _setter("autoscale_cooldown", autoscale_cooldown)
+ pulumi.set(__self__, "autoscale_cooldown", autoscale_cooldown)
if autoscale_down is not None:
- _setter("autoscale_down", autoscale_down)
+ pulumi.set(__self__, "autoscale_down", autoscale_down)
if autoscale_headroom is not None:
- _setter("autoscale_headroom", autoscale_headroom)
+ pulumi.set(__self__, "autoscale_headroom", autoscale_headroom)
if autoscale_is_enabled is not None:
- _setter("autoscale_is_enabled", autoscale_is_enabled)
+ pulumi.set(__self__, "autoscale_is_enabled", autoscale_is_enabled)
@property
@pulumi.getter(name="masterHost")
@@ -3341,25 +2548,8 @@ def __init__(__self__, *,
"""
:param str value: The dimension value.
"""
- ElastigroupIntegrationNomadAutoscaleConstraint._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -3399,21 +2589,8 @@ def __init__(__self__, *,
"""
:param int evaluation_periods: The number of periods over which data is compared to the specified threshold.
"""
- ElastigroupIntegrationNomadAutoscaleDown._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- evaluation_periods=evaluation_periods,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- evaluation_periods: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
-
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
@property
@pulumi.getter(name="evaluationPeriods")
@@ -3456,33 +2633,12 @@ def __init__(__self__, *,
:param int memory_per_unit: How much Memory allocate for headroom unit.
:param int num_of_units: How many units of headroom to allocate.
"""
- ElastigroupIntegrationNomadAutoscaleHeadroom._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cpu_per_unit=cpu_per_unit,
- memory_per_unit=memory_per_unit,
- num_of_units=num_of_units,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cpu_per_unit: Optional[int] = None,
- memory_per_unit: Optional[int] = None,
- num_of_units: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cpu_per_unit is None and 'cpuPerUnit' in kwargs:
- cpu_per_unit = kwargs['cpuPerUnit']
- if memory_per_unit is None and 'memoryPerUnit' in kwargs:
- memory_per_unit = kwargs['memoryPerUnit']
- if num_of_units is None and 'numOfUnits' in kwargs:
- num_of_units = kwargs['numOfUnits']
-
if cpu_per_unit is not None:
- _setter("cpu_per_unit", cpu_per_unit)
+ pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
if memory_per_unit is not None:
- _setter("memory_per_unit", memory_per_unit)
+ pulumi.set(__self__, "memory_per_unit", memory_per_unit)
if num_of_units is not None:
- _setter("num_of_units", num_of_units)
+ pulumi.set(__self__, "num_of_units", num_of_units)
@property
@pulumi.getter(name="cpuPerUnit")
@@ -3548,40 +2704,11 @@ def __init__(__self__, *,
import pulumi
```
"""
- ElastigroupIntegrationRancher._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- access_key=access_key,
- master_host=master_host,
- secret_key=secret_key,
- version=version,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- access_key: Optional[str] = None,
- master_host: Optional[str] = None,
- secret_key: Optional[str] = None,
- version: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if access_key is None and 'accessKey' in kwargs:
- access_key = kwargs['accessKey']
- if access_key is None:
- raise TypeError("Missing 'access_key' argument")
- if master_host is None and 'masterHost' in kwargs:
- master_host = kwargs['masterHost']
- if master_host is None:
- raise TypeError("Missing 'master_host' argument")
- if secret_key is None and 'secretKey' in kwargs:
- secret_key = kwargs['secretKey']
- if secret_key is None:
- raise TypeError("Missing 'secret_key' argument")
-
- _setter("access_key", access_key)
- _setter("master_host", master_host)
- _setter("secret_key", secret_key)
+ pulumi.set(__self__, "access_key", access_key)
+ pulumi.set(__self__, "master_host", master_host)
+ pulumi.set(__self__, "secret_key", secret_key)
if version is not None:
- _setter("version", version)
+ pulumi.set(__self__, "version", version)
@property
@pulumi.getter(name="accessKey")
@@ -3628,20 +2755,7 @@ def __init__(__self__, *,
"""
:param Sequence['ElastigroupIntegrationRoute53DomainArgs'] domains: Collection of one or more domains to register.
"""
- ElastigroupIntegrationRoute53._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- domains=domains,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- domains: Optional[Sequence['outputs.ElastigroupIntegrationRoute53Domain']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if domains is None:
- raise TypeError("Missing 'domains' argument")
-
- _setter("domains", domains)
+ pulumi.set(__self__, "domains", domains)
@property
@pulumi.getter
@@ -3688,41 +2802,12 @@ def __init__(__self__, *,
:param str record_set_type: The type of the record set. Valid values: `"a"`, `"cname"`.
:param str spotinst_acct_id: The Spotinst account ID that is linked to the AWS account that holds the Route 53 Hosted Zone ID. The default is the user Spotinst account provided as a URL parameter.
"""
- ElastigroupIntegrationRoute53Domain._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- hosted_zone_id=hosted_zone_id,
- record_sets=record_sets,
- record_set_type=record_set_type,
- spotinst_acct_id=spotinst_acct_id,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- hosted_zone_id: Optional[str] = None,
- record_sets: Optional[Sequence['outputs.ElastigroupIntegrationRoute53DomainRecordSet']] = None,
- record_set_type: Optional[str] = None,
- spotinst_acct_id: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if hosted_zone_id is None and 'hostedZoneId' in kwargs:
- hosted_zone_id = kwargs['hostedZoneId']
- if hosted_zone_id is None:
- raise TypeError("Missing 'hosted_zone_id' argument")
- if record_sets is None and 'recordSets' in kwargs:
- record_sets = kwargs['recordSets']
- if record_sets is None:
- raise TypeError("Missing 'record_sets' argument")
- if record_set_type is None and 'recordSetType' in kwargs:
- record_set_type = kwargs['recordSetType']
- if spotinst_acct_id is None and 'spotinstAcctId' in kwargs:
- spotinst_acct_id = kwargs['spotinstAcctId']
-
- _setter("hosted_zone_id", hosted_zone_id)
- _setter("record_sets", record_sets)
+ pulumi.set(__self__, "hosted_zone_id", hosted_zone_id)
+ pulumi.set(__self__, "record_sets", record_sets)
if record_set_type is not None:
- _setter("record_set_type", record_set_type)
+ pulumi.set(__self__, "record_set_type", record_set_type)
if spotinst_acct_id is not None:
- _setter("spotinst_acct_id", spotinst_acct_id)
+ pulumi.set(__self__, "spotinst_acct_id", spotinst_acct_id)
@property
@pulumi.getter(name="hostedZoneId")
@@ -3793,32 +2878,11 @@ def __init__(__self__, *,
```
:param bool use_public_ip: Designates whether the IP address should be exposed to connections outside the VPC.
"""
- ElastigroupIntegrationRoute53DomainRecordSet._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- use_public_dns=use_public_dns,
- use_public_ip=use_public_ip,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[str] = None,
- use_public_dns: Optional[bool] = None,
- use_public_ip: Optional[bool] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
- if use_public_dns is None and 'usePublicDns' in kwargs:
- use_public_dns = kwargs['usePublicDns']
- if use_public_ip is None and 'usePublicIp' in kwargs:
- use_public_ip = kwargs['usePublicIp']
-
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if use_public_dns is not None:
- _setter("use_public_dns", use_public_dns)
+ pulumi.set(__self__, "use_public_dns", use_public_dns)
if use_public_ip is not None:
- _setter("use_public_ip", use_public_ip)
+ pulumi.set(__self__, "use_public_ip", use_public_ip)
@property
@pulumi.getter
@@ -3887,55 +2951,14 @@ def __init__(__self__, *,
weight_strategy: str,
default_static_target_group: Optional['outputs.ElastigroupItfDefaultStaticTargetGroup'] = None,
migration_healthiness_threshold: Optional[int] = None):
- ElastigroupItf._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- fixed_target_groups=fixed_target_groups,
- load_balancers=load_balancers,
- target_group_configs=target_group_configs,
- weight_strategy=weight_strategy,
- default_static_target_group=default_static_target_group,
- migration_healthiness_threshold=migration_healthiness_threshold,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- fixed_target_groups: Optional[bool] = None,
- load_balancers: Optional[Sequence['outputs.ElastigroupItfLoadBalancer']] = None,
- target_group_configs: Optional[Sequence['outputs.ElastigroupItfTargetGroupConfig']] = None,
- weight_strategy: Optional[str] = None,
- default_static_target_group: Optional['outputs.ElastigroupItfDefaultStaticTargetGroup'] = None,
- migration_healthiness_threshold: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if fixed_target_groups is None and 'fixedTargetGroups' in kwargs:
- fixed_target_groups = kwargs['fixedTargetGroups']
- if fixed_target_groups is None:
- raise TypeError("Missing 'fixed_target_groups' argument")
- if load_balancers is None and 'loadBalancers' in kwargs:
- load_balancers = kwargs['loadBalancers']
- if load_balancers is None:
- raise TypeError("Missing 'load_balancers' argument")
- if target_group_configs is None and 'targetGroupConfigs' in kwargs:
- target_group_configs = kwargs['targetGroupConfigs']
- if target_group_configs is None:
- raise TypeError("Missing 'target_group_configs' argument")
- if weight_strategy is None and 'weightStrategy' in kwargs:
- weight_strategy = kwargs['weightStrategy']
- if weight_strategy is None:
- raise TypeError("Missing 'weight_strategy' argument")
- if default_static_target_group is None and 'defaultStaticTargetGroup' in kwargs:
- default_static_target_group = kwargs['defaultStaticTargetGroup']
- if migration_healthiness_threshold is None and 'migrationHealthinessThreshold' in kwargs:
- migration_healthiness_threshold = kwargs['migrationHealthinessThreshold']
-
- _setter("fixed_target_groups", fixed_target_groups)
- _setter("load_balancers", load_balancers)
- _setter("target_group_configs", target_group_configs)
- _setter("weight_strategy", weight_strategy)
+ pulumi.set(__self__, "fixed_target_groups", fixed_target_groups)
+ pulumi.set(__self__, "load_balancers", load_balancers)
+ pulumi.set(__self__, "target_group_configs", target_group_configs)
+ pulumi.set(__self__, "weight_strategy", weight_strategy)
if default_static_target_group is not None:
- _setter("default_static_target_group", default_static_target_group)
+ pulumi.set(__self__, "default_static_target_group", default_static_target_group)
if migration_healthiness_threshold is not None:
- _setter("migration_healthiness_threshold", migration_healthiness_threshold)
+ pulumi.set(__self__, "migration_healthiness_threshold", migration_healthiness_threshold)
@property
@pulumi.getter(name="fixedTargetGroups")
@@ -3973,25 +2996,8 @@ class ElastigroupItfDefaultStaticTargetGroup(dict):
def __init__(__self__, *,
arn: str,
percentage: float):
- ElastigroupItfDefaultStaticTargetGroup._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- arn=arn,
- percentage=percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- arn: Optional[str] = None,
- percentage: Optional[float] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if arn is None:
- raise TypeError("Missing 'arn' argument")
- if percentage is None:
- raise TypeError("Missing 'percentage' argument")
-
- _setter("arn", arn)
- _setter("percentage", percentage)
+ pulumi.set(__self__, "arn", arn)
+ pulumi.set(__self__, "percentage", percentage)
@property
@pulumi.getter
@@ -4028,29 +3034,8 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
listener_rules: Sequence['outputs.ElastigroupItfLoadBalancerListenerRule'],
load_balancer_arn: str):
- ElastigroupItfLoadBalancer._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- listener_rules=listener_rules,
- load_balancer_arn=load_balancer_arn,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- listener_rules: Optional[Sequence['outputs.ElastigroupItfLoadBalancerListenerRule']] = None,
- load_balancer_arn: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if listener_rules is None and 'listenerRules' in kwargs:
- listener_rules = kwargs['listenerRules']
- if listener_rules is None:
- raise TypeError("Missing 'listener_rules' argument")
- if load_balancer_arn is None and 'loadBalancerArn' in kwargs:
- load_balancer_arn = kwargs['loadBalancerArn']
- if load_balancer_arn is None:
- raise TypeError("Missing 'load_balancer_arn' argument")
-
- _setter("listener_rules", listener_rules)
- _setter("load_balancer_arn", load_balancer_arn)
+ pulumi.set(__self__, "listener_rules", listener_rules)
+ pulumi.set(__self__, "load_balancer_arn", load_balancer_arn)
@property
@pulumi.getter(name="listenerRules")
@@ -4087,28 +3072,9 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
rule_arn: str,
static_target_group: Optional['outputs.ElastigroupItfLoadBalancerListenerRuleStaticTargetGroup'] = None):
- ElastigroupItfLoadBalancerListenerRule._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- rule_arn=rule_arn,
- static_target_group=static_target_group,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- rule_arn: Optional[str] = None,
- static_target_group: Optional['outputs.ElastigroupItfLoadBalancerListenerRuleStaticTargetGroup'] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if rule_arn is None and 'ruleArn' in kwargs:
- rule_arn = kwargs['ruleArn']
- if rule_arn is None:
- raise TypeError("Missing 'rule_arn' argument")
- if static_target_group is None and 'staticTargetGroup' in kwargs:
- static_target_group = kwargs['staticTargetGroup']
-
- _setter("rule_arn", rule_arn)
+ pulumi.set(__self__, "rule_arn", rule_arn)
if static_target_group is not None:
- _setter("static_target_group", static_target_group)
+ pulumi.set(__self__, "static_target_group", static_target_group)
@property
@pulumi.getter(name="ruleArn")
@@ -4126,25 +3092,8 @@ class ElastigroupItfLoadBalancerListenerRuleStaticTargetGroup(dict):
def __init__(__self__, *,
arn: str,
percentage: float):
- ElastigroupItfLoadBalancerListenerRuleStaticTargetGroup._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- arn=arn,
- percentage=percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- arn: Optional[str] = None,
- percentage: Optional[float] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if arn is None:
- raise TypeError("Missing 'arn' argument")
- if percentage is None:
- raise TypeError("Missing 'percentage' argument")
-
- _setter("arn", arn)
- _setter("percentage", percentage)
+ pulumi.set(__self__, "arn", arn)
+ pulumi.set(__self__, "percentage", percentage)
@property
@pulumi.getter
@@ -4209,89 +3158,28 @@ def __init__(__self__, *,
"""
:param Sequence['ElastigroupItfTargetGroupConfigTagArgs'] tags: A key/value mapping of tags to assign to the resource.
"""
- ElastigroupItfTargetGroupConfig._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- health_check_path=health_check_path,
- port=port,
- protocol=protocol,
- vpc_id=vpc_id,
- health_check_interval_seconds=health_check_interval_seconds,
- health_check_port=health_check_port,
- health_check_protocol=health_check_protocol,
- health_check_timeout_seconds=health_check_timeout_seconds,
- healthy_threshold_count=healthy_threshold_count,
- matchers=matchers,
- protocol_version=protocol_version,
- tags=tags,
- unhealthy_threshold_count=unhealthy_threshold_count,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- health_check_path: Optional[str] = None,
- port: Optional[int] = None,
- protocol: Optional[str] = None,
- vpc_id: Optional[str] = None,
- health_check_interval_seconds: Optional[int] = None,
- health_check_port: Optional[str] = None,
- health_check_protocol: Optional[str] = None,
- health_check_timeout_seconds: Optional[int] = None,
- healthy_threshold_count: Optional[int] = None,
- matchers: Optional[Sequence['outputs.ElastigroupItfTargetGroupConfigMatcher']] = None,
- protocol_version: Optional[str] = None,
- tags: Optional[Sequence['outputs.ElastigroupItfTargetGroupConfigTag']] = None,
- unhealthy_threshold_count: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if health_check_path is None and 'healthCheckPath' in kwargs:
- health_check_path = kwargs['healthCheckPath']
- if health_check_path is None:
- raise TypeError("Missing 'health_check_path' argument")
- if port is None:
- raise TypeError("Missing 'port' argument")
- if protocol is None:
- raise TypeError("Missing 'protocol' argument")
- if vpc_id is None and 'vpcId' in kwargs:
- vpc_id = kwargs['vpcId']
- if vpc_id is None:
- raise TypeError("Missing 'vpc_id' argument")
- if health_check_interval_seconds is None and 'healthCheckIntervalSeconds' in kwargs:
- health_check_interval_seconds = kwargs['healthCheckIntervalSeconds']
- if health_check_port is None and 'healthCheckPort' in kwargs:
- health_check_port = kwargs['healthCheckPort']
- if health_check_protocol is None and 'healthCheckProtocol' in kwargs:
- health_check_protocol = kwargs['healthCheckProtocol']
- if health_check_timeout_seconds is None and 'healthCheckTimeoutSeconds' in kwargs:
- health_check_timeout_seconds = kwargs['healthCheckTimeoutSeconds']
- if healthy_threshold_count is None and 'healthyThresholdCount' in kwargs:
- healthy_threshold_count = kwargs['healthyThresholdCount']
- if protocol_version is None and 'protocolVersion' in kwargs:
- protocol_version = kwargs['protocolVersion']
- if unhealthy_threshold_count is None and 'unhealthyThresholdCount' in kwargs:
- unhealthy_threshold_count = kwargs['unhealthyThresholdCount']
-
- _setter("health_check_path", health_check_path)
- _setter("port", port)
- _setter("protocol", protocol)
- _setter("vpc_id", vpc_id)
+ pulumi.set(__self__, "health_check_path", health_check_path)
+ pulumi.set(__self__, "port", port)
+ pulumi.set(__self__, "protocol", protocol)
+ pulumi.set(__self__, "vpc_id", vpc_id)
if health_check_interval_seconds is not None:
- _setter("health_check_interval_seconds", health_check_interval_seconds)
+ pulumi.set(__self__, "health_check_interval_seconds", health_check_interval_seconds)
if health_check_port is not None:
- _setter("health_check_port", health_check_port)
+ pulumi.set(__self__, "health_check_port", health_check_port)
if health_check_protocol is not None:
- _setter("health_check_protocol", health_check_protocol)
+ pulumi.set(__self__, "health_check_protocol", health_check_protocol)
if health_check_timeout_seconds is not None:
- _setter("health_check_timeout_seconds", health_check_timeout_seconds)
+ pulumi.set(__self__, "health_check_timeout_seconds", health_check_timeout_seconds)
if healthy_threshold_count is not None:
- _setter("healthy_threshold_count", healthy_threshold_count)
+ pulumi.set(__self__, "healthy_threshold_count", healthy_threshold_count)
if matchers is not None:
- _setter("matchers", matchers)
+ pulumi.set(__self__, "matchers", matchers)
if protocol_version is not None:
- _setter("protocol_version", protocol_version)
+ pulumi.set(__self__, "protocol_version", protocol_version)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
if unhealthy_threshold_count is not None:
- _setter("unhealthy_threshold_count", unhealthy_threshold_count)
+ pulumi.set(__self__, "unhealthy_threshold_count", unhealthy_threshold_count)
@property
@pulumi.getter(name="healthCheckPath")
@@ -4386,27 +3274,10 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
grpc_code: Optional[str] = None,
http_code: Optional[str] = None):
- ElastigroupItfTargetGroupConfigMatcher._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- grpc_code=grpc_code,
- http_code=http_code,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- grpc_code: Optional[str] = None,
- http_code: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if grpc_code is None and 'grpcCode' in kwargs:
- grpc_code = kwargs['grpcCode']
- if http_code is None and 'httpCode' in kwargs:
- http_code = kwargs['httpCode']
-
if grpc_code is not None:
- _setter("grpc_code", grpc_code)
+ pulumi.set(__self__, "grpc_code", grpc_code)
if http_code is not None:
- _setter("http_code", http_code)
+ pulumi.set(__self__, "http_code", http_code)
@property
@pulumi.getter(name="grpcCode")
@@ -4443,28 +3314,9 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
tag_key: str,
tag_value: Optional[str] = None):
- ElastigroupItfTargetGroupConfigTag._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- tag_key=tag_key,
- tag_value=tag_value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- tag_key: Optional[str] = None,
- tag_value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if tag_key is None and 'tagKey' in kwargs:
- tag_key = kwargs['tagKey']
- if tag_key is None:
- raise TypeError("Missing 'tag_key' argument")
- if tag_value is None and 'tagValue' in kwargs:
- tag_value = kwargs['tagValue']
-
- _setter("tag_key", tag_key)
+ pulumi.set(__self__, "tag_key", tag_key)
if tag_value is not None:
- _setter("tag_value", tag_value)
+ pulumi.set(__self__, "tag_value", tag_value)
@property
@pulumi.getter(name="tagKey")
@@ -4509,34 +3361,11 @@ def __init__(__self__, *,
:param int http_put_response_hop_limit: The desired HTTP PUT response hop limit for instance metadata requests. The larger the number, the further instance metadata requests can travel. Valid values: Integers from `1` to `64`.
:param str instance_metadata_tags: Indicates whether access to instance tags from the instance metadata is enabled or disabled. Can’t be null.
"""
- ElastigroupMetadataOptions._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- http_tokens=http_tokens,
- http_put_response_hop_limit=http_put_response_hop_limit,
- instance_metadata_tags=instance_metadata_tags,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- http_tokens: Optional[str] = None,
- http_put_response_hop_limit: Optional[int] = None,
- instance_metadata_tags: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if http_tokens is None and 'httpTokens' in kwargs:
- http_tokens = kwargs['httpTokens']
- if http_tokens is None:
- raise TypeError("Missing 'http_tokens' argument")
- if http_put_response_hop_limit is None and 'httpPutResponseHopLimit' in kwargs:
- http_put_response_hop_limit = kwargs['httpPutResponseHopLimit']
- if instance_metadata_tags is None and 'instanceMetadataTags' in kwargs:
- instance_metadata_tags = kwargs['instanceMetadataTags']
-
- _setter("http_tokens", http_tokens)
+ pulumi.set(__self__, "http_tokens", http_tokens)
if http_put_response_hop_limit is not None:
- _setter("http_put_response_hop_limit", http_put_response_hop_limit)
+ pulumi.set(__self__, "http_put_response_hop_limit", http_put_response_hop_limit)
if instance_metadata_tags is not None:
- _setter("instance_metadata_tags", instance_metadata_tags)
+ pulumi.set(__self__, "instance_metadata_tags", instance_metadata_tags)
@property
@pulumi.getter(name="httpTokens")
@@ -4597,29 +3426,8 @@ def __init__(__self__, *,
```
:param str target_set_id: ID of Multai target set.
"""
- ElastigroupMultaiTargetSet._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- balancer_id=balancer_id,
- target_set_id=target_set_id,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- balancer_id: Optional[str] = None,
- target_set_id: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if balancer_id is None and 'balancerId' in kwargs:
- balancer_id = kwargs['balancerId']
- if balancer_id is None:
- raise TypeError("Missing 'balancer_id' argument")
- if target_set_id is None and 'targetSetId' in kwargs:
- target_set_id = kwargs['targetSetId']
- if target_set_id is None:
- raise TypeError("Missing 'target_set_id' argument")
-
- _setter("balancer_id", balancer_id)
- _setter("target_set_id", target_set_id)
+ pulumi.set(__self__, "balancer_id", balancer_id)
+ pulumi.set(__self__, "target_set_id", target_set_id)
@property
@pulumi.getter(name="balancerId")
@@ -4653,23 +3461,10 @@ def __init__(__self__, *,
:param Sequence['ElastigroupMultipleMetricsExpressionArgs'] expressions: Array of objects (Expression config)
:param Sequence['ElastigroupMultipleMetricsMetricArgs'] metrics: Array of objects (Metric config)
"""
- ElastigroupMultipleMetrics._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- expressions=expressions,
- metrics=metrics,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- expressions: Optional[Sequence['outputs.ElastigroupMultipleMetricsExpression']] = None,
- metrics: Optional[Sequence['outputs.ElastigroupMultipleMetricsMetric']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if expressions is not None:
- _setter("expressions", expressions)
+ pulumi.set(__self__, "expressions", expressions)
if metrics is not None:
- _setter("metrics", metrics)
+ pulumi.set(__self__, "metrics", metrics)
@property
@pulumi.getter
@@ -4697,25 +3492,8 @@ def __init__(__self__, *,
:param str expression: An expression consisting of the metric names listed in the 'metrics' array.
:param str name: The group name.
"""
- ElastigroupMultipleMetricsExpression._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- expression=expression,
- name=name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- expression: Optional[str] = None,
- name: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if expression is None:
- raise TypeError("Missing 'expression' argument")
- if name is None:
- raise TypeError("Missing 'name' argument")
-
- _setter("expression", expression)
- _setter("name", name)
+ pulumi.set(__self__, "expression", expression)
+ pulumi.set(__self__, "name", name)
@property
@pulumi.getter
@@ -4772,50 +3550,17 @@ def __init__(__self__, *,
:param str statistic: The metric statistics to return. For information about specific statistics go to [Statistics](http://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/index.html?CHAP_TerminologyandKeyConcepts.html#Statistic) in the Amazon CloudWatch Developer Guide.
:param str unit: The unit for the alarm's associated metric. Valid values: `"percent`, `"seconds"`, `"microseconds"`, `"milliseconds"`, `"bytes"`, `"kilobytes"`, `"megabytes"`, `"gigabytes"`, `"terabytes"`, `"bits"`, `"kilobits"`, `"megabits"`, `"gigabits"`, `"terabits"`, `"count"`, `"bytes/second"`, `"kilobytes/second"`, `"megabytes/second"`, `"gigabytes/second"`, `"terabytes/second"`, `"bits/second"`, `"kilobits/second"`, `"megabits/second"`, `"gigabits/second"`, `"terabits/second"`, `"count/second"`, `"none"`.
"""
- ElastigroupMultipleMetricsMetric._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- metric_name=metric_name,
- name=name,
- namespace=namespace,
- dimensions=dimensions,
- extended_statistic=extended_statistic,
- statistic=statistic,
- unit=unit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- metric_name: Optional[str] = None,
- name: Optional[str] = None,
- namespace: Optional[str] = None,
- dimensions: Optional[Sequence['outputs.ElastigroupMultipleMetricsMetricDimension']] = None,
- extended_statistic: Optional[str] = None,
- statistic: Optional[str] = None,
- unit: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if metric_name is None and 'metricName' in kwargs:
- metric_name = kwargs['metricName']
- if metric_name is None:
- raise TypeError("Missing 'metric_name' argument")
- if name is None:
- raise TypeError("Missing 'name' argument")
- if namespace is None:
- raise TypeError("Missing 'namespace' argument")
- if extended_statistic is None and 'extendedStatistic' in kwargs:
- extended_statistic = kwargs['extendedStatistic']
-
- _setter("metric_name", metric_name)
- _setter("name", name)
- _setter("namespace", namespace)
+ pulumi.set(__self__, "metric_name", metric_name)
+ pulumi.set(__self__, "name", name)
+ pulumi.set(__self__, "namespace", namespace)
if dimensions is not None:
- _setter("dimensions", dimensions)
+ pulumi.set(__self__, "dimensions", dimensions)
if extended_statistic is not None:
- _setter("extended_statistic", extended_statistic)
+ pulumi.set(__self__, "extended_statistic", extended_statistic)
if statistic is not None:
- _setter("statistic", statistic)
+ pulumi.set(__self__, "statistic", statistic)
if unit is not None:
- _setter("unit", unit)
+ pulumi.set(__self__, "unit", unit)
@property
@pulumi.getter(name="metricName")
@@ -4883,24 +3628,9 @@ def __init__(__self__, *,
:param str name: The group name.
:param str value: The dimension value.
"""
- ElastigroupMultipleMetricsMetricDimension._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
-
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if value is not None:
- _setter("value", value)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -4975,62 +3705,21 @@ def __init__(__self__, *,
:param str private_ip_address: The private IP address of the network interface.
:param str secondary_private_ip_address_count: The number of secondary private IP addresses.
"""
- ElastigroupNetworkInterface._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- device_index=device_index,
- associate_ipv6_address=associate_ipv6_address,
- associate_public_ip_address=associate_public_ip_address,
- delete_on_termination=delete_on_termination,
- description=description,
- network_interface_id=network_interface_id,
- private_ip_address=private_ip_address,
- secondary_private_ip_address_count=secondary_private_ip_address_count,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- device_index: Optional[str] = None,
- associate_ipv6_address: Optional[bool] = None,
- associate_public_ip_address: Optional[bool] = None,
- delete_on_termination: Optional[bool] = None,
- description: Optional[str] = None,
- network_interface_id: Optional[str] = None,
- private_ip_address: Optional[str] = None,
- secondary_private_ip_address_count: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if device_index is None and 'deviceIndex' in kwargs:
- device_index = kwargs['deviceIndex']
- if device_index is None:
- raise TypeError("Missing 'device_index' argument")
- if associate_ipv6_address is None and 'associateIpv6Address' in kwargs:
- associate_ipv6_address = kwargs['associateIpv6Address']
- if associate_public_ip_address is None and 'associatePublicIpAddress' in kwargs:
- associate_public_ip_address = kwargs['associatePublicIpAddress']
- if delete_on_termination is None and 'deleteOnTermination' in kwargs:
- delete_on_termination = kwargs['deleteOnTermination']
- if network_interface_id is None and 'networkInterfaceId' in kwargs:
- network_interface_id = kwargs['networkInterfaceId']
- if private_ip_address is None and 'privateIpAddress' in kwargs:
- private_ip_address = kwargs['privateIpAddress']
- if secondary_private_ip_address_count is None and 'secondaryPrivateIpAddressCount' in kwargs:
- secondary_private_ip_address_count = kwargs['secondaryPrivateIpAddressCount']
-
- _setter("device_index", device_index)
+ pulumi.set(__self__, "device_index", device_index)
if associate_ipv6_address is not None:
- _setter("associate_ipv6_address", associate_ipv6_address)
+ pulumi.set(__self__, "associate_ipv6_address", associate_ipv6_address)
if associate_public_ip_address is not None:
- _setter("associate_public_ip_address", associate_public_ip_address)
+ pulumi.set(__self__, "associate_public_ip_address", associate_public_ip_address)
if delete_on_termination is not None:
- _setter("delete_on_termination", delete_on_termination)
+ pulumi.set(__self__, "delete_on_termination", delete_on_termination)
if description is not None:
- _setter("description", description)
+ pulumi.set(__self__, "description", description)
if network_interface_id is not None:
- _setter("network_interface_id", network_interface_id)
+ pulumi.set(__self__, "network_interface_id", network_interface_id)
if private_ip_address is not None:
- _setter("private_ip_address", private_ip_address)
+ pulumi.set(__self__, "private_ip_address", private_ip_address)
if secondary_private_ip_address_count is not None:
- _setter("secondary_private_ip_address_count", secondary_private_ip_address_count)
+ pulumi.set(__self__, "secondary_private_ip_address_count", secondary_private_ip_address_count)
@property
@pulumi.getter(name="deviceIndex")
@@ -5159,73 +3848,20 @@ def __init__(__self__, *,
:param int required_gpu_maximum: Required maximum instance GPU (<=16)
:param int required_gpu_minimum: Required minimum instance GPU (>=1)
"""
- ElastigroupResourceRequirement._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- required_memory_maximum=required_memory_maximum,
- required_memory_minimum=required_memory_minimum,
- required_vcpu_maximum=required_vcpu_maximum,
- required_vcpu_minimum=required_vcpu_minimum,
- excluded_instance_families=excluded_instance_families,
- excluded_instance_generations=excluded_instance_generations,
- excluded_instance_types=excluded_instance_types,
- required_gpu_maximum=required_gpu_maximum,
- required_gpu_minimum=required_gpu_minimum,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- required_memory_maximum: Optional[int] = None,
- required_memory_minimum: Optional[int] = None,
- required_vcpu_maximum: Optional[int] = None,
- required_vcpu_minimum: Optional[int] = None,
- excluded_instance_families: Optional[Sequence[str]] = None,
- excluded_instance_generations: Optional[Sequence[str]] = None,
- excluded_instance_types: Optional[Sequence[str]] = None,
- required_gpu_maximum: Optional[int] = None,
- required_gpu_minimum: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if required_memory_maximum is None and 'requiredMemoryMaximum' in kwargs:
- required_memory_maximum = kwargs['requiredMemoryMaximum']
- if required_memory_maximum is None:
- raise TypeError("Missing 'required_memory_maximum' argument")
- if required_memory_minimum is None and 'requiredMemoryMinimum' in kwargs:
- required_memory_minimum = kwargs['requiredMemoryMinimum']
- if required_memory_minimum is None:
- raise TypeError("Missing 'required_memory_minimum' argument")
- if required_vcpu_maximum is None and 'requiredVcpuMaximum' in kwargs:
- required_vcpu_maximum = kwargs['requiredVcpuMaximum']
- if required_vcpu_maximum is None:
- raise TypeError("Missing 'required_vcpu_maximum' argument")
- if required_vcpu_minimum is None and 'requiredVcpuMinimum' in kwargs:
- required_vcpu_minimum = kwargs['requiredVcpuMinimum']
- if required_vcpu_minimum is None:
- raise TypeError("Missing 'required_vcpu_minimum' argument")
- if excluded_instance_families is None and 'excludedInstanceFamilies' in kwargs:
- excluded_instance_families = kwargs['excludedInstanceFamilies']
- if excluded_instance_generations is None and 'excludedInstanceGenerations' in kwargs:
- excluded_instance_generations = kwargs['excludedInstanceGenerations']
- if excluded_instance_types is None and 'excludedInstanceTypes' in kwargs:
- excluded_instance_types = kwargs['excludedInstanceTypes']
- if required_gpu_maximum is None and 'requiredGpuMaximum' in kwargs:
- required_gpu_maximum = kwargs['requiredGpuMaximum']
- if required_gpu_minimum is None and 'requiredGpuMinimum' in kwargs:
- required_gpu_minimum = kwargs['requiredGpuMinimum']
-
- _setter("required_memory_maximum", required_memory_maximum)
- _setter("required_memory_minimum", required_memory_minimum)
- _setter("required_vcpu_maximum", required_vcpu_maximum)
- _setter("required_vcpu_minimum", required_vcpu_minimum)
+ pulumi.set(__self__, "required_memory_maximum", required_memory_maximum)
+ pulumi.set(__self__, "required_memory_minimum", required_memory_minimum)
+ pulumi.set(__self__, "required_vcpu_maximum", required_vcpu_maximum)
+ pulumi.set(__self__, "required_vcpu_minimum", required_vcpu_minimum)
if excluded_instance_families is not None:
- _setter("excluded_instance_families", excluded_instance_families)
+ pulumi.set(__self__, "excluded_instance_families", excluded_instance_families)
if excluded_instance_generations is not None:
- _setter("excluded_instance_generations", excluded_instance_generations)
+ pulumi.set(__self__, "excluded_instance_generations", excluded_instance_generations)
if excluded_instance_types is not None:
- _setter("excluded_instance_types", excluded_instance_types)
+ pulumi.set(__self__, "excluded_instance_types", excluded_instance_types)
if required_gpu_maximum is not None:
- _setter("required_gpu_maximum", required_gpu_maximum)
+ pulumi.set(__self__, "required_gpu_maximum", required_gpu_maximum)
if required_gpu_minimum is not None:
- _setter("required_gpu_minimum", required_gpu_minimum)
+ pulumi.set(__self__, "required_gpu_minimum", required_gpu_minimum)
@property
@pulumi.getter(name="requiredMemoryMaximum")
@@ -5336,39 +3972,14 @@ def __init__(__self__, *,
:param bool should_tag_snapshots: Tag specification for Snapshot resources.
:param bool should_tag_volumes: Tag specification for Volume resources.
"""
- ElastigroupResourceTagSpecification._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- should_tag_amis=should_tag_amis,
- should_tag_enis=should_tag_enis,
- should_tag_snapshots=should_tag_snapshots,
- should_tag_volumes=should_tag_volumes,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- should_tag_amis: Optional[bool] = None,
- should_tag_enis: Optional[bool] = None,
- should_tag_snapshots: Optional[bool] = None,
- should_tag_volumes: Optional[bool] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if should_tag_amis is None and 'shouldTagAmis' in kwargs:
- should_tag_amis = kwargs['shouldTagAmis']
- if should_tag_enis is None and 'shouldTagEnis' in kwargs:
- should_tag_enis = kwargs['shouldTagEnis']
- if should_tag_snapshots is None and 'shouldTagSnapshots' in kwargs:
- should_tag_snapshots = kwargs['shouldTagSnapshots']
- if should_tag_volumes is None and 'shouldTagVolumes' in kwargs:
- should_tag_volumes = kwargs['shouldTagVolumes']
-
if should_tag_amis is not None:
- _setter("should_tag_amis", should_tag_amis)
+ pulumi.set(__self__, "should_tag_amis", should_tag_amis)
if should_tag_enis is not None:
- _setter("should_tag_enis", should_tag_enis)
+ pulumi.set(__self__, "should_tag_enis", should_tag_enis)
if should_tag_snapshots is not None:
- _setter("should_tag_snapshots", should_tag_snapshots)
+ pulumi.set(__self__, "should_tag_snapshots", should_tag_snapshots)
if should_tag_volumes is not None:
- _setter("should_tag_volumes", should_tag_volumes)
+ pulumi.set(__self__, "should_tag_volumes", should_tag_volumes)
@property
@pulumi.getter(name="shouldTagAmis")
@@ -5431,28 +4042,9 @@ def __init__(__self__, *,
:param str perform_at: In the event of a fallback to On-Demand instances, select the time period to revert back to Spot. Supported Arguments – always (default), timeWindow, never. For timeWindow or never to be valid the group must have availabilityOriented OR persistence defined.
:param Sequence[str] time_windows: Specify a list of time windows for to execute revertToSpot strategy. Time window format: `ddd:hh:mm-ddd:hh:mm`. Example: `Mon:03:00-Wed:02:30`
"""
- ElastigroupRevertToSpot._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- perform_at=perform_at,
- time_windows=time_windows,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- perform_at: Optional[str] = None,
- time_windows: Optional[Sequence[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if perform_at is None and 'performAt' in kwargs:
- perform_at = kwargs['performAt']
- if perform_at is None:
- raise TypeError("Missing 'perform_at' argument")
- if time_windows is None and 'timeWindows' in kwargs:
- time_windows = kwargs['timeWindows']
-
- _setter("perform_at", perform_at)
+ pulumi.set(__self__, "perform_at", perform_at)
if time_windows is not None:
- _setter("time_windows", time_windows)
+ pulumi.set(__self__, "time_windows", time_windows)
@property
@pulumi.getter(name="performAt")
@@ -5555,118 +4147,45 @@ def __init__(__self__, *,
When using `updateCapacity` – set the fields `minimum`, `maximum`, and `target`
:param str unit: The unit for the alarm's associated metric. Valid values: `"percent`, `"seconds"`, `"microseconds"`, `"milliseconds"`, `"bytes"`, `"kilobytes"`, `"megabytes"`, `"gigabytes"`, `"terabytes"`, `"bits"`, `"kilobits"`, `"megabits"`, `"gigabits"`, `"terabits"`, `"count"`, `"bytes/second"`, `"kilobytes/second"`, `"megabytes/second"`, `"gigabytes/second"`, `"terabytes/second"`, `"bits/second"`, `"kilobits/second"`, `"megabits/second"`, `"gigabits/second"`, `"terabits/second"`, `"count/second"`, `"none"`.
"""
- ElastigroupScalingDownPolicy._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- metric_name=metric_name,
- namespace=namespace,
- policy_name=policy_name,
- action_type=action_type,
- adjustment=adjustment,
- cooldown=cooldown,
- dimensions=dimensions,
- evaluation_periods=evaluation_periods,
- is_enabled=is_enabled,
- max_target_capacity=max_target_capacity,
- maximum=maximum,
- min_target_capacity=min_target_capacity,
- minimum=minimum,
- operator=operator,
- period=period,
- source=source,
- statistic=statistic,
- step_adjustments=step_adjustments,
- target=target,
- threshold=threshold,
- unit=unit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- metric_name: Optional[str] = None,
- namespace: Optional[str] = None,
- policy_name: Optional[str] = None,
- action_type: Optional[str] = None,
- adjustment: Optional[str] = None,
- cooldown: Optional[int] = None,
- dimensions: Optional[Sequence['outputs.ElastigroupScalingDownPolicyDimension']] = None,
- evaluation_periods: Optional[int] = None,
- is_enabled: Optional[bool] = None,
- max_target_capacity: Optional[str] = None,
- maximum: Optional[str] = None,
- min_target_capacity: Optional[str] = None,
- minimum: Optional[str] = None,
- operator: Optional[str] = None,
- period: Optional[int] = None,
- source: Optional[str] = None,
- statistic: Optional[str] = None,
- step_adjustments: Optional[Sequence['outputs.ElastigroupScalingDownPolicyStepAdjustment']] = None,
- target: Optional[str] = None,
- threshold: Optional[float] = None,
- unit: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if metric_name is None and 'metricName' in kwargs:
- metric_name = kwargs['metricName']
- if metric_name is None:
- raise TypeError("Missing 'metric_name' argument")
- if namespace is None:
- raise TypeError("Missing 'namespace' argument")
- if policy_name is None and 'policyName' in kwargs:
- policy_name = kwargs['policyName']
- if policy_name is None:
- raise TypeError("Missing 'policy_name' argument")
- if action_type is None and 'actionType' in kwargs:
- action_type = kwargs['actionType']
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
- if max_target_capacity is None and 'maxTargetCapacity' in kwargs:
- max_target_capacity = kwargs['maxTargetCapacity']
- if min_target_capacity is None and 'minTargetCapacity' in kwargs:
- min_target_capacity = kwargs['minTargetCapacity']
- if step_adjustments is None and 'stepAdjustments' in kwargs:
- step_adjustments = kwargs['stepAdjustments']
-
- _setter("metric_name", metric_name)
- _setter("namespace", namespace)
- _setter("policy_name", policy_name)
+ pulumi.set(__self__, "metric_name", metric_name)
+ pulumi.set(__self__, "namespace", namespace)
+ pulumi.set(__self__, "policy_name", policy_name)
if action_type is not None:
- _setter("action_type", action_type)
+ pulumi.set(__self__, "action_type", action_type)
if adjustment is not None:
- _setter("adjustment", adjustment)
+ pulumi.set(__self__, "adjustment", adjustment)
if cooldown is not None:
- _setter("cooldown", cooldown)
+ pulumi.set(__self__, "cooldown", cooldown)
if dimensions is not None:
- _setter("dimensions", dimensions)
+ pulumi.set(__self__, "dimensions", dimensions)
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
if is_enabled is not None:
- _setter("is_enabled", is_enabled)
+ pulumi.set(__self__, "is_enabled", is_enabled)
if max_target_capacity is not None:
- _setter("max_target_capacity", max_target_capacity)
+ pulumi.set(__self__, "max_target_capacity", max_target_capacity)
if maximum is not None:
- _setter("maximum", maximum)
+ pulumi.set(__self__, "maximum", maximum)
if min_target_capacity is not None:
- _setter("min_target_capacity", min_target_capacity)
+ pulumi.set(__self__, "min_target_capacity", min_target_capacity)
if minimum is not None:
- _setter("minimum", minimum)
+ pulumi.set(__self__, "minimum", minimum)
if operator is not None:
- _setter("operator", operator)
+ pulumi.set(__self__, "operator", operator)
if period is not None:
- _setter("period", period)
+ pulumi.set(__self__, "period", period)
if source is not None:
- _setter("source", source)
+ pulumi.set(__self__, "source", source)
if statistic is not None:
- _setter("statistic", statistic)
+ pulumi.set(__self__, "statistic", statistic)
if step_adjustments is not None:
- _setter("step_adjustments", step_adjustments)
+ pulumi.set(__self__, "step_adjustments", step_adjustments)
if target is not None:
- _setter("target", target)
+ pulumi.set(__self__, "target", target)
if threshold is not None:
- _setter("threshold", threshold)
+ pulumi.set(__self__, "threshold", threshold)
if unit is not None:
- _setter("unit", unit)
+ pulumi.set(__self__, "unit", unit)
@property
@pulumi.getter(name="metricName")
@@ -5850,24 +4369,9 @@ def __init__(__self__, *,
:param str name: The group name.
:param str value: The dimension value.
"""
- ElastigroupScalingDownPolicyDimension._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
-
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if value is not None:
- _setter("value", value)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -5902,25 +4406,8 @@ def __init__(__self__, *,
When using `adjustment` – set the field `adjustment`
When using `updateCapacity` – set the fields `minimum`, `maximum`, and `target`
"""
- ElastigroupScalingDownPolicyStepAdjustment._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- action=action,
- threshold=threshold,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- action: Optional['outputs.ElastigroupScalingDownPolicyStepAdjustmentAction'] = None,
- threshold: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if action is None:
- raise TypeError("Missing 'action' argument")
- if threshold is None:
- raise TypeError("Missing 'threshold' argument")
-
- _setter("action", action)
- _setter("threshold", threshold)
+ pulumi.set(__self__, "action", action)
+ pulumi.set(__self__, "threshold", threshold)
@property
@pulumi.getter
@@ -5984,48 +4471,19 @@ def __init__(__self__, *,
:param str minimum: The minimal number of instances to have in the group.
:param str target: The target number of instances to have in the group.
"""
- ElastigroupScalingDownPolicyStepAdjustmentAction._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- type=type,
- adjustment=adjustment,
- max_target_capacity=max_target_capacity,
- maximum=maximum,
- min_target_capacity=min_target_capacity,
- minimum=minimum,
- target=target,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- type: Optional[str] = None,
- adjustment: Optional[str] = None,
- max_target_capacity: Optional[str] = None,
- maximum: Optional[str] = None,
- min_target_capacity: Optional[str] = None,
- minimum: Optional[str] = None,
- target: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if type is None:
- raise TypeError("Missing 'type' argument")
- if max_target_capacity is None and 'maxTargetCapacity' in kwargs:
- max_target_capacity = kwargs['maxTargetCapacity']
- if min_target_capacity is None and 'minTargetCapacity' in kwargs:
- min_target_capacity = kwargs['minTargetCapacity']
-
- _setter("type", type)
+ pulumi.set(__self__, "type", type)
if adjustment is not None:
- _setter("adjustment", adjustment)
+ pulumi.set(__self__, "adjustment", adjustment)
if max_target_capacity is not None:
- _setter("max_target_capacity", max_target_capacity)
+ pulumi.set(__self__, "max_target_capacity", max_target_capacity)
if maximum is not None:
- _setter("maximum", maximum)
+ pulumi.set(__self__, "maximum", maximum)
if min_target_capacity is not None:
- _setter("min_target_capacity", min_target_capacity)
+ pulumi.set(__self__, "min_target_capacity", min_target_capacity)
if minimum is not None:
- _setter("minimum", minimum)
+ pulumi.set(__self__, "minimum", minimum)
if target is not None:
- _setter("target", target)
+ pulumi.set(__self__, "target", target)
@property
@pulumi.getter
@@ -6112,27 +4570,10 @@ def __init__(__self__, *,
:param bool terminate_at_end_of_billing_hour: Specify whether to terminate instances at the end of each billing hour.
:param str termination_policy: Determines whether to terminate the newest instances when performing a scaling action. Valid values: `"default"`, `"newestInstance"`.
"""
- ElastigroupScalingStrategy._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- terminate_at_end_of_billing_hour=terminate_at_end_of_billing_hour,
- termination_policy=termination_policy,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- terminate_at_end_of_billing_hour: Optional[bool] = None,
- termination_policy: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if terminate_at_end_of_billing_hour is None and 'terminateAtEndOfBillingHour' in kwargs:
- terminate_at_end_of_billing_hour = kwargs['terminateAtEndOfBillingHour']
- if termination_policy is None and 'terminationPolicy' in kwargs:
- termination_policy = kwargs['terminationPolicy']
-
if terminate_at_end_of_billing_hour is not None:
- _setter("terminate_at_end_of_billing_hour", terminate_at_end_of_billing_hour)
+ pulumi.set(__self__, "terminate_at_end_of_billing_hour", terminate_at_end_of_billing_hour)
if termination_policy is not None:
- _setter("termination_policy", termination_policy)
+ pulumi.set(__self__, "termination_policy", termination_policy)
@property
@pulumi.getter(name="terminateAtEndOfBillingHour")
@@ -6219,81 +4660,28 @@ def __init__(__self__, *,
:param str statistic: String, the metric statistics to return. For information about specific statistics go to [Statistics](http://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/index.html?CHAP_TerminologyandKeyConcepts.html#Statistic) in the Amazon CloudWatch Developer Guide.
:param str unit: String, tThe unit for the alarm's associated metric. Valid values: `"percent`, `"seconds"`, `"microseconds"`, `"milliseconds"`, `"bytes"`, `"kilobytes"`, `"megabytes"`, `"gigabytes"`, `"terabytes"`, `"bits"`, `"kilobits"`, `"megabits"`, `"gigabits"`, `"terabits"`, `"count"`, `"bytes/second"`, `"kilobytes/second"`, `"megabytes/second"`, `"gigabytes/second"`, `"terabytes/second"`, `"bits/second"`, `"kilobits/second"`, `"megabits/second"`, `"gigabits/second"`, `"terabits/second"`, `"count/second"`, `"none"`.
"""
- ElastigroupScalingTargetPolicy._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- metric_name=metric_name,
- namespace=namespace,
- policy_name=policy_name,
- target=target,
- cooldown=cooldown,
- dimensions=dimensions,
- evaluation_periods=evaluation_periods,
- max_capacity_per_scale=max_capacity_per_scale,
- period=period,
- predictive_mode=predictive_mode,
- source=source,
- statistic=statistic,
- unit=unit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- metric_name: Optional[str] = None,
- namespace: Optional[str] = None,
- policy_name: Optional[str] = None,
- target: Optional[float] = None,
- cooldown: Optional[int] = None,
- dimensions: Optional[Sequence['outputs.ElastigroupScalingTargetPolicyDimension']] = None,
- evaluation_periods: Optional[int] = None,
- max_capacity_per_scale: Optional[str] = None,
- period: Optional[int] = None,
- predictive_mode: Optional[str] = None,
- source: Optional[str] = None,
- statistic: Optional[str] = None,
- unit: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if metric_name is None and 'metricName' in kwargs:
- metric_name = kwargs['metricName']
- if metric_name is None:
- raise TypeError("Missing 'metric_name' argument")
- if namespace is None:
- raise TypeError("Missing 'namespace' argument")
- if policy_name is None and 'policyName' in kwargs:
- policy_name = kwargs['policyName']
- if policy_name is None:
- raise TypeError("Missing 'policy_name' argument")
- if target is None:
- raise TypeError("Missing 'target' argument")
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
- if max_capacity_per_scale is None and 'maxCapacityPerScale' in kwargs:
- max_capacity_per_scale = kwargs['maxCapacityPerScale']
- if predictive_mode is None and 'predictiveMode' in kwargs:
- predictive_mode = kwargs['predictiveMode']
-
- _setter("metric_name", metric_name)
- _setter("namespace", namespace)
- _setter("policy_name", policy_name)
- _setter("target", target)
+ pulumi.set(__self__, "metric_name", metric_name)
+ pulumi.set(__self__, "namespace", namespace)
+ pulumi.set(__self__, "policy_name", policy_name)
+ pulumi.set(__self__, "target", target)
if cooldown is not None:
- _setter("cooldown", cooldown)
+ pulumi.set(__self__, "cooldown", cooldown)
if dimensions is not None:
- _setter("dimensions", dimensions)
+ pulumi.set(__self__, "dimensions", dimensions)
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
if max_capacity_per_scale is not None:
- _setter("max_capacity_per_scale", max_capacity_per_scale)
+ pulumi.set(__self__, "max_capacity_per_scale", max_capacity_per_scale)
if period is not None:
- _setter("period", period)
+ pulumi.set(__self__, "period", period)
if predictive_mode is not None:
- _setter("predictive_mode", predictive_mode)
+ pulumi.set(__self__, "predictive_mode", predictive_mode)
if source is not None:
- _setter("source", source)
+ pulumi.set(__self__, "source", source)
if statistic is not None:
- _setter("statistic", statistic)
+ pulumi.set(__self__, "statistic", statistic)
if unit is not None:
- _setter("unit", unit)
+ pulumi.set(__self__, "unit", unit)
@property
@pulumi.getter(name="metricName")
@@ -6421,24 +4809,9 @@ def __init__(__self__, *,
:param str name: The group name.
:param str value: The dimension value.
"""
- ElastigroupScalingTargetPolicyDimension._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
-
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if value is not None:
- _setter("value", value)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -6542,118 +4915,45 @@ def __init__(__self__, *,
When using `updateCapacity` – set the fields `minimum`, `maximum`, and `target`
:param str unit: The unit for the alarm's associated metric. Valid values: `"percent`, `"seconds"`, `"microseconds"`, `"milliseconds"`, `"bytes"`, `"kilobytes"`, `"megabytes"`, `"gigabytes"`, `"terabytes"`, `"bits"`, `"kilobits"`, `"megabits"`, `"gigabits"`, `"terabits"`, `"count"`, `"bytes/second"`, `"kilobytes/second"`, `"megabytes/second"`, `"gigabytes/second"`, `"terabytes/second"`, `"bits/second"`, `"kilobits/second"`, `"megabits/second"`, `"gigabits/second"`, `"terabits/second"`, `"count/second"`, `"none"`.
"""
- ElastigroupScalingUpPolicy._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- metric_name=metric_name,
- namespace=namespace,
- policy_name=policy_name,
- action_type=action_type,
- adjustment=adjustment,
- cooldown=cooldown,
- dimensions=dimensions,
- evaluation_periods=evaluation_periods,
- is_enabled=is_enabled,
- max_target_capacity=max_target_capacity,
- maximum=maximum,
- min_target_capacity=min_target_capacity,
- minimum=minimum,
- operator=operator,
- period=period,
- source=source,
- statistic=statistic,
- step_adjustments=step_adjustments,
- target=target,
- threshold=threshold,
- unit=unit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- metric_name: Optional[str] = None,
- namespace: Optional[str] = None,
- policy_name: Optional[str] = None,
- action_type: Optional[str] = None,
- adjustment: Optional[str] = None,
- cooldown: Optional[int] = None,
- dimensions: Optional[Sequence['outputs.ElastigroupScalingUpPolicyDimension']] = None,
- evaluation_periods: Optional[int] = None,
- is_enabled: Optional[bool] = None,
- max_target_capacity: Optional[str] = None,
- maximum: Optional[str] = None,
- min_target_capacity: Optional[str] = None,
- minimum: Optional[str] = None,
- operator: Optional[str] = None,
- period: Optional[int] = None,
- source: Optional[str] = None,
- statistic: Optional[str] = None,
- step_adjustments: Optional[Sequence['outputs.ElastigroupScalingUpPolicyStepAdjustment']] = None,
- target: Optional[str] = None,
- threshold: Optional[float] = None,
- unit: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if metric_name is None and 'metricName' in kwargs:
- metric_name = kwargs['metricName']
- if metric_name is None:
- raise TypeError("Missing 'metric_name' argument")
- if namespace is None:
- raise TypeError("Missing 'namespace' argument")
- if policy_name is None and 'policyName' in kwargs:
- policy_name = kwargs['policyName']
- if policy_name is None:
- raise TypeError("Missing 'policy_name' argument")
- if action_type is None and 'actionType' in kwargs:
- action_type = kwargs['actionType']
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
- if max_target_capacity is None and 'maxTargetCapacity' in kwargs:
- max_target_capacity = kwargs['maxTargetCapacity']
- if min_target_capacity is None and 'minTargetCapacity' in kwargs:
- min_target_capacity = kwargs['minTargetCapacity']
- if step_adjustments is None and 'stepAdjustments' in kwargs:
- step_adjustments = kwargs['stepAdjustments']
-
- _setter("metric_name", metric_name)
- _setter("namespace", namespace)
- _setter("policy_name", policy_name)
+ pulumi.set(__self__, "metric_name", metric_name)
+ pulumi.set(__self__, "namespace", namespace)
+ pulumi.set(__self__, "policy_name", policy_name)
if action_type is not None:
- _setter("action_type", action_type)
+ pulumi.set(__self__, "action_type", action_type)
if adjustment is not None:
- _setter("adjustment", adjustment)
+ pulumi.set(__self__, "adjustment", adjustment)
if cooldown is not None:
- _setter("cooldown", cooldown)
+ pulumi.set(__self__, "cooldown", cooldown)
if dimensions is not None:
- _setter("dimensions", dimensions)
+ pulumi.set(__self__, "dimensions", dimensions)
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
if is_enabled is not None:
- _setter("is_enabled", is_enabled)
+ pulumi.set(__self__, "is_enabled", is_enabled)
if max_target_capacity is not None:
- _setter("max_target_capacity", max_target_capacity)
+ pulumi.set(__self__, "max_target_capacity", max_target_capacity)
if maximum is not None:
- _setter("maximum", maximum)
+ pulumi.set(__self__, "maximum", maximum)
if min_target_capacity is not None:
- _setter("min_target_capacity", min_target_capacity)
+ pulumi.set(__self__, "min_target_capacity", min_target_capacity)
if minimum is not None:
- _setter("minimum", minimum)
+ pulumi.set(__self__, "minimum", minimum)
if operator is not None:
- _setter("operator", operator)
+ pulumi.set(__self__, "operator", operator)
if period is not None:
- _setter("period", period)
+ pulumi.set(__self__, "period", period)
if source is not None:
- _setter("source", source)
+ pulumi.set(__self__, "source", source)
if statistic is not None:
- _setter("statistic", statistic)
+ pulumi.set(__self__, "statistic", statistic)
if step_adjustments is not None:
- _setter("step_adjustments", step_adjustments)
+ pulumi.set(__self__, "step_adjustments", step_adjustments)
if target is not None:
- _setter("target", target)
+ pulumi.set(__self__, "target", target)
if threshold is not None:
- _setter("threshold", threshold)
+ pulumi.set(__self__, "threshold", threshold)
if unit is not None:
- _setter("unit", unit)
+ pulumi.set(__self__, "unit", unit)
@property
@pulumi.getter(name="metricName")
@@ -6838,24 +5138,9 @@ def __init__(__self__, *,
:param str name: The group name.
:param str value: The dimension value.
"""
- ElastigroupScalingUpPolicyDimension._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
-
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if value is not None:
- _setter("value", value)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -6890,25 +5175,8 @@ def __init__(__self__, *,
When using `adjustment` – set the field `adjustment`
When using `updateCapacity` – set the fields `minimum`, `maximum`, and `target`
"""
- ElastigroupScalingUpPolicyStepAdjustment._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- action=action,
- threshold=threshold,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- action: Optional['outputs.ElastigroupScalingUpPolicyStepAdjustmentAction'] = None,
- threshold: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if action is None:
- raise TypeError("Missing 'action' argument")
- if threshold is None:
- raise TypeError("Missing 'threshold' argument")
-
- _setter("action", action)
- _setter("threshold", threshold)
+ pulumi.set(__self__, "action", action)
+ pulumi.set(__self__, "threshold", threshold)
@property
@pulumi.getter
@@ -6972,48 +5240,19 @@ def __init__(__self__, *,
:param str minimum: The minimal number of instances to have in the group.
:param str target: The target number of instances to have in the group.
"""
- ElastigroupScalingUpPolicyStepAdjustmentAction._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- type=type,
- adjustment=adjustment,
- max_target_capacity=max_target_capacity,
- maximum=maximum,
- min_target_capacity=min_target_capacity,
- minimum=minimum,
- target=target,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- type: Optional[str] = None,
- adjustment: Optional[str] = None,
- max_target_capacity: Optional[str] = None,
- maximum: Optional[str] = None,
- min_target_capacity: Optional[str] = None,
- minimum: Optional[str] = None,
- target: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if type is None:
- raise TypeError("Missing 'type' argument")
- if max_target_capacity is None and 'maxTargetCapacity' in kwargs:
- max_target_capacity = kwargs['maxTargetCapacity']
- if min_target_capacity is None and 'minTargetCapacity' in kwargs:
- min_target_capacity = kwargs['minTargetCapacity']
-
- _setter("type", type)
+ pulumi.set(__self__, "type", type)
if adjustment is not None:
- _setter("adjustment", adjustment)
+ pulumi.set(__self__, "adjustment", adjustment)
if max_target_capacity is not None:
- _setter("max_target_capacity", max_target_capacity)
+ pulumi.set(__self__, "max_target_capacity", max_target_capacity)
if maximum is not None:
- _setter("maximum", maximum)
+ pulumi.set(__self__, "maximum", maximum)
if min_target_capacity is not None:
- _setter("min_target_capacity", min_target_capacity)
+ pulumi.set(__self__, "min_target_capacity", min_target_capacity)
if minimum is not None:
- _setter("minimum", minimum)
+ pulumi.set(__self__, "minimum", minimum)
if target is not None:
- _setter("target", target)
+ pulumi.set(__self__, "target", target)
@property
@pulumi.getter
@@ -7154,102 +5393,35 @@ def __init__(__self__, *,
:param str start_time: Set a start time for one time tasks.
:param str target_capacity: The desired number of instances the group should have.
"""
- ElastigroupScheduledTask._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- task_type=task_type,
- adjustment=adjustment,
- adjustment_percentage=adjustment_percentage,
- batch_size_percentage=batch_size_percentage,
- cron_expression=cron_expression,
- frequency=frequency,
- grace_period=grace_period,
- is_enabled=is_enabled,
- max_capacity=max_capacity,
- min_capacity=min_capacity,
- scale_max_capacity=scale_max_capacity,
- scale_min_capacity=scale_min_capacity,
- scale_target_capacity=scale_target_capacity,
- start_time=start_time,
- target_capacity=target_capacity,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- task_type: Optional[str] = None,
- adjustment: Optional[str] = None,
- adjustment_percentage: Optional[str] = None,
- batch_size_percentage: Optional[str] = None,
- cron_expression: Optional[str] = None,
- frequency: Optional[str] = None,
- grace_period: Optional[str] = None,
- is_enabled: Optional[bool] = None,
- max_capacity: Optional[str] = None,
- min_capacity: Optional[str] = None,
- scale_max_capacity: Optional[str] = None,
- scale_min_capacity: Optional[str] = None,
- scale_target_capacity: Optional[str] = None,
- start_time: Optional[str] = None,
- target_capacity: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if task_type is None and 'taskType' in kwargs:
- task_type = kwargs['taskType']
- if task_type is None:
- raise TypeError("Missing 'task_type' argument")
- if adjustment_percentage is None and 'adjustmentPercentage' in kwargs:
- adjustment_percentage = kwargs['adjustmentPercentage']
- if batch_size_percentage is None and 'batchSizePercentage' in kwargs:
- batch_size_percentage = kwargs['batchSizePercentage']
- if cron_expression is None and 'cronExpression' in kwargs:
- cron_expression = kwargs['cronExpression']
- if grace_period is None and 'gracePeriod' in kwargs:
- grace_period = kwargs['gracePeriod']
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
- if max_capacity is None and 'maxCapacity' in kwargs:
- max_capacity = kwargs['maxCapacity']
- if min_capacity is None and 'minCapacity' in kwargs:
- min_capacity = kwargs['minCapacity']
- if scale_max_capacity is None and 'scaleMaxCapacity' in kwargs:
- scale_max_capacity = kwargs['scaleMaxCapacity']
- if scale_min_capacity is None and 'scaleMinCapacity' in kwargs:
- scale_min_capacity = kwargs['scaleMinCapacity']
- if scale_target_capacity is None and 'scaleTargetCapacity' in kwargs:
- scale_target_capacity = kwargs['scaleTargetCapacity']
- if start_time is None and 'startTime' in kwargs:
- start_time = kwargs['startTime']
- if target_capacity is None and 'targetCapacity' in kwargs:
- target_capacity = kwargs['targetCapacity']
-
- _setter("task_type", task_type)
+ pulumi.set(__self__, "task_type", task_type)
if adjustment is not None:
- _setter("adjustment", adjustment)
+ pulumi.set(__self__, "adjustment", adjustment)
if adjustment_percentage is not None:
- _setter("adjustment_percentage", adjustment_percentage)
+ pulumi.set(__self__, "adjustment_percentage", adjustment_percentage)
if batch_size_percentage is not None:
- _setter("batch_size_percentage", batch_size_percentage)
+ pulumi.set(__self__, "batch_size_percentage", batch_size_percentage)
if cron_expression is not None:
- _setter("cron_expression", cron_expression)
+ pulumi.set(__self__, "cron_expression", cron_expression)
if frequency is not None:
- _setter("frequency", frequency)
+ pulumi.set(__self__, "frequency", frequency)
if grace_period is not None:
- _setter("grace_period", grace_period)
+ pulumi.set(__self__, "grace_period", grace_period)
if is_enabled is not None:
- _setter("is_enabled", is_enabled)
+ pulumi.set(__self__, "is_enabled", is_enabled)
if max_capacity is not None:
- _setter("max_capacity", max_capacity)
+ pulumi.set(__self__, "max_capacity", max_capacity)
if min_capacity is not None:
- _setter("min_capacity", min_capacity)
+ pulumi.set(__self__, "min_capacity", min_capacity)
if scale_max_capacity is not None:
- _setter("scale_max_capacity", scale_max_capacity)
+ pulumi.set(__self__, "scale_max_capacity", scale_max_capacity)
if scale_min_capacity is not None:
- _setter("scale_min_capacity", scale_min_capacity)
+ pulumi.set(__self__, "scale_min_capacity", scale_min_capacity)
if scale_target_capacity is not None:
- _setter("scale_target_capacity", scale_target_capacity)
+ pulumi.set(__self__, "scale_target_capacity", scale_target_capacity)
if start_time is not None:
- _setter("start_time", start_time)
+ pulumi.set(__self__, "start_time", start_time)
if target_capacity is not None:
- _setter("target_capacity", target_capacity)
+ pulumi.set(__self__, "target_capacity", target_capacity)
@property
@pulumi.getter(name="taskType")
@@ -7393,24 +5565,9 @@ def __init__(__self__, *,
import pulumi
```
"""
- ElastigroupSignal._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- timeout=timeout,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[str] = None,
- timeout: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
-
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if timeout is not None:
- _setter("timeout", timeout)
+ pulumi.set(__self__, "timeout", timeout)
@property
@pulumi.getter
@@ -7477,39 +5634,14 @@ def __init__(__self__, *,
```
:param bool should_delete_volumes: For stateful groups: remove persistent volumes.
"""
- ElastigroupStatefulDeallocation._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- should_delete_images=should_delete_images,
- should_delete_network_interfaces=should_delete_network_interfaces,
- should_delete_snapshots=should_delete_snapshots,
- should_delete_volumes=should_delete_volumes,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- should_delete_images: Optional[bool] = None,
- should_delete_network_interfaces: Optional[bool] = None,
- should_delete_snapshots: Optional[bool] = None,
- should_delete_volumes: Optional[bool] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if should_delete_images is None and 'shouldDeleteImages' in kwargs:
- should_delete_images = kwargs['shouldDeleteImages']
- if should_delete_network_interfaces is None and 'shouldDeleteNetworkInterfaces' in kwargs:
- should_delete_network_interfaces = kwargs['shouldDeleteNetworkInterfaces']
- if should_delete_snapshots is None and 'shouldDeleteSnapshots' in kwargs:
- should_delete_snapshots = kwargs['shouldDeleteSnapshots']
- if should_delete_volumes is None and 'shouldDeleteVolumes' in kwargs:
- should_delete_volumes = kwargs['shouldDeleteVolumes']
-
if should_delete_images is not None:
- _setter("should_delete_images", should_delete_images)
+ pulumi.set(__self__, "should_delete_images", should_delete_images)
if should_delete_network_interfaces is not None:
- _setter("should_delete_network_interfaces", should_delete_network_interfaces)
+ pulumi.set(__self__, "should_delete_network_interfaces", should_delete_network_interfaces)
if should_delete_snapshots is not None:
- _setter("should_delete_snapshots", should_delete_snapshots)
+ pulumi.set(__self__, "should_delete_snapshots", should_delete_snapshots)
if should_delete_volumes is not None:
- _setter("should_delete_volumes", should_delete_volumes)
+ pulumi.set(__self__, "should_delete_volumes", should_delete_volumes)
@property
@pulumi.getter(name="shouldDeleteImages")
@@ -7582,27 +5714,8 @@ def __init__(__self__, *,
import pulumi
```
"""
- ElastigroupStatefulInstanceAction._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- stateful_instance_id=stateful_instance_id,
- type=type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- stateful_instance_id: Optional[str] = None,
- type: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if stateful_instance_id is None and 'statefulInstanceId' in kwargs:
- stateful_instance_id = kwargs['statefulInstanceId']
- if stateful_instance_id is None:
- raise TypeError("Missing 'stateful_instance_id' argument")
- if type is None:
- raise TypeError("Missing 'type' argument")
-
- _setter("stateful_instance_id", stateful_instance_id)
- _setter("type", type)
+ pulumi.set(__self__, "stateful_instance_id", stateful_instance_id)
+ pulumi.set(__self__, "type", type)
@property
@pulumi.getter(name="statefulInstanceId")
@@ -7635,23 +5748,10 @@ def __init__(__self__, *,
"""
:param str value: The dimension value.
"""
- ElastigroupTag._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if key is not None:
- _setter("key", key)
+ pulumi.set(__self__, "key", key)
if value is not None:
- _setter("value", value)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -7703,41 +5803,12 @@ def __init__(__self__, *,
:param bool auto_apply_tags: Enables updates to tags without rolling the group when set to `true`.
:param 'ElastigroupUpdatePolicyRollConfigArgs' roll_config: While used, you can control whether the group should perform a deployment after an update to the configuration.
"""
- ElastigroupUpdatePolicy._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- should_resume_stateful=should_resume_stateful,
- should_roll=should_roll,
- auto_apply_tags=auto_apply_tags,
- roll_config=roll_config,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- should_resume_stateful: Optional[bool] = None,
- should_roll: Optional[bool] = None,
- auto_apply_tags: Optional[bool] = None,
- roll_config: Optional['outputs.ElastigroupUpdatePolicyRollConfig'] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if should_resume_stateful is None and 'shouldResumeStateful' in kwargs:
- should_resume_stateful = kwargs['shouldResumeStateful']
- if should_resume_stateful is None:
- raise TypeError("Missing 'should_resume_stateful' argument")
- if should_roll is None and 'shouldRoll' in kwargs:
- should_roll = kwargs['shouldRoll']
- if should_roll is None:
- raise TypeError("Missing 'should_roll' argument")
- if auto_apply_tags is None and 'autoApplyTags' in kwargs:
- auto_apply_tags = kwargs['autoApplyTags']
- if roll_config is None and 'rollConfig' in kwargs:
- roll_config = kwargs['rollConfig']
-
- _setter("should_resume_stateful", should_resume_stateful)
- _setter("should_roll", should_roll)
+ pulumi.set(__self__, "should_resume_stateful", should_resume_stateful)
+ pulumi.set(__self__, "should_roll", should_roll)
if auto_apply_tags is not None:
- _setter("auto_apply_tags", auto_apply_tags)
+ pulumi.set(__self__, "auto_apply_tags", auto_apply_tags)
if roll_config is not None:
- _setter("roll_config", roll_config)
+ pulumi.set(__self__, "roll_config", roll_config)
@property
@pulumi.getter(name="shouldResumeStateful")
@@ -7814,50 +5885,17 @@ def __init__(__self__, *,
:param float wait_for_roll_percentage: For use with `should_roll`. Sets minimum % of roll required to complete before continuing the plan. Required if `wait_for_roll_timeout` is set.
:param int wait_for_roll_timeout: For use with `should_roll`. Sets how long to wait for the deployed % of a roll to exceed `wait_for_roll_percentage` before continuing the plan. Required if `wait_for_roll_percentage` is set.
"""
- ElastigroupUpdatePolicyRollConfig._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- batch_size_percentage=batch_size_percentage,
- grace_period=grace_period,
- health_check_type=health_check_type,
- strategy=strategy,
- wait_for_roll_percentage=wait_for_roll_percentage,
- wait_for_roll_timeout=wait_for_roll_timeout,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- batch_size_percentage: Optional[int] = None,
- grace_period: Optional[int] = None,
- health_check_type: Optional[str] = None,
- strategy: Optional['outputs.ElastigroupUpdatePolicyRollConfigStrategy'] = None,
- wait_for_roll_percentage: Optional[float] = None,
- wait_for_roll_timeout: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if batch_size_percentage is None and 'batchSizePercentage' in kwargs:
- batch_size_percentage = kwargs['batchSizePercentage']
- if batch_size_percentage is None:
- raise TypeError("Missing 'batch_size_percentage' argument")
- if grace_period is None and 'gracePeriod' in kwargs:
- grace_period = kwargs['gracePeriod']
- if health_check_type is None and 'healthCheckType' in kwargs:
- health_check_type = kwargs['healthCheckType']
- if wait_for_roll_percentage is None and 'waitForRollPercentage' in kwargs:
- wait_for_roll_percentage = kwargs['waitForRollPercentage']
- if wait_for_roll_timeout is None and 'waitForRollTimeout' in kwargs:
- wait_for_roll_timeout = kwargs['waitForRollTimeout']
-
- _setter("batch_size_percentage", batch_size_percentage)
+ pulumi.set(__self__, "batch_size_percentage", batch_size_percentage)
if grace_period is not None:
- _setter("grace_period", grace_period)
+ pulumi.set(__self__, "grace_period", grace_period)
if health_check_type is not None:
- _setter("health_check_type", health_check_type)
+ pulumi.set(__self__, "health_check_type", health_check_type)
if strategy is not None:
- _setter("strategy", strategy)
+ pulumi.set(__self__, "strategy", strategy)
if wait_for_roll_percentage is not None:
- _setter("wait_for_roll_percentage", wait_for_roll_percentage)
+ pulumi.set(__self__, "wait_for_roll_percentage", wait_for_roll_percentage)
if wait_for_roll_timeout is not None:
- _setter("wait_for_roll_timeout", wait_for_roll_timeout)
+ pulumi.set(__self__, "wait_for_roll_timeout", wait_for_roll_timeout)
@property
@pulumi.getter(name="batchSizePercentage")
@@ -7942,38 +5980,13 @@ def __init__(__self__, *,
:param 'ElastigroupUpdatePolicyRollConfigStrategyOnFailureArgs' on_failure: Set detach options to the deployment.
:param bool should_drain_instances: Bool value if to wait to drain instance
"""
- ElastigroupUpdatePolicyRollConfigStrategy._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- action=action,
- batch_min_healthy_percentage=batch_min_healthy_percentage,
- on_failure=on_failure,
- should_drain_instances=should_drain_instances,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- action: Optional[str] = None,
- batch_min_healthy_percentage: Optional[int] = None,
- on_failure: Optional['outputs.ElastigroupUpdatePolicyRollConfigStrategyOnFailure'] = None,
- should_drain_instances: Optional[bool] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if action is None:
- raise TypeError("Missing 'action' argument")
- if batch_min_healthy_percentage is None and 'batchMinHealthyPercentage' in kwargs:
- batch_min_healthy_percentage = kwargs['batchMinHealthyPercentage']
- if on_failure is None and 'onFailure' in kwargs:
- on_failure = kwargs['onFailure']
- if should_drain_instances is None and 'shouldDrainInstances' in kwargs:
- should_drain_instances = kwargs['shouldDrainInstances']
-
- _setter("action", action)
+ pulumi.set(__self__, "action", action)
if batch_min_healthy_percentage is not None:
- _setter("batch_min_healthy_percentage", batch_min_healthy_percentage)
+ pulumi.set(__self__, "batch_min_healthy_percentage", batch_min_healthy_percentage)
if on_failure is not None:
- _setter("on_failure", on_failure)
+ pulumi.set(__self__, "on_failure", on_failure)
if should_drain_instances is not None:
- _setter("should_drain_instances", should_drain_instances)
+ pulumi.set(__self__, "should_drain_instances", should_drain_instances)
@property
@pulumi.getter
@@ -8051,46 +6064,15 @@ def __init__(__self__, *,
```
:param bool should_handle_all_batches: Indicator if the action should apply to all batches of the deployment or only the latest batch.
"""
- ElastigroupUpdatePolicyRollConfigStrategyOnFailure._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- action_type=action_type,
- batch_num=batch_num,
- draining_timeout=draining_timeout,
- should_decrement_target_capacity=should_decrement_target_capacity,
- should_handle_all_batches=should_handle_all_batches,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- action_type: Optional[str] = None,
- batch_num: Optional[int] = None,
- draining_timeout: Optional[int] = None,
- should_decrement_target_capacity: Optional[bool] = None,
- should_handle_all_batches: Optional[bool] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if action_type is None and 'actionType' in kwargs:
- action_type = kwargs['actionType']
- if action_type is None:
- raise TypeError("Missing 'action_type' argument")
- if batch_num is None and 'batchNum' in kwargs:
- batch_num = kwargs['batchNum']
- if draining_timeout is None and 'drainingTimeout' in kwargs:
- draining_timeout = kwargs['drainingTimeout']
- if should_decrement_target_capacity is None and 'shouldDecrementTargetCapacity' in kwargs:
- should_decrement_target_capacity = kwargs['shouldDecrementTargetCapacity']
- if should_handle_all_batches is None and 'shouldHandleAllBatches' in kwargs:
- should_handle_all_batches = kwargs['shouldHandleAllBatches']
-
- _setter("action_type", action_type)
+ pulumi.set(__self__, "action_type", action_type)
if batch_num is not None:
- _setter("batch_num", batch_num)
+ pulumi.set(__self__, "batch_num", batch_num)
if draining_timeout is not None:
- _setter("draining_timeout", draining_timeout)
+ pulumi.set(__self__, "draining_timeout", draining_timeout)
if should_decrement_target_capacity is not None:
- _setter("should_decrement_target_capacity", should_decrement_target_capacity)
+ pulumi.set(__self__, "should_decrement_target_capacity", should_decrement_target_capacity)
if should_handle_all_batches is not None:
- _setter("should_handle_all_batches", should_handle_all_batches)
+ pulumi.set(__self__, "should_handle_all_batches", should_handle_all_batches)
@property
@pulumi.getter(name="actionType")
@@ -8156,26 +6138,9 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
device_name: str,
ebs: Optional['outputs.ManagedInstanceBlockDeviceMappingEbs'] = None):
- ManagedInstanceBlockDeviceMapping._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- device_name=device_name,
- ebs=ebs,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- device_name: Optional[str] = None,
- ebs: Optional['outputs.ManagedInstanceBlockDeviceMappingEbs'] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if device_name is None and 'deviceName' in kwargs:
- device_name = kwargs['deviceName']
- if device_name is None:
- raise TypeError("Missing 'device_name' argument")
-
- _setter("device_name", device_name)
+ pulumi.set(__self__, "device_name", device_name)
if ebs is not None:
- _setter("ebs", ebs)
+ pulumi.set(__self__, "ebs", ebs)
@property
@pulumi.getter(name="deviceName")
@@ -8217,41 +6182,16 @@ def __init__(__self__, *,
throughput: Optional[int] = None,
volume_size: Optional[int] = None,
volume_type: Optional[str] = None):
- ManagedInstanceBlockDeviceMappingEbs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- delete_on_termination=delete_on_termination,
- iops=iops,
- throughput=throughput,
- volume_size=volume_size,
- volume_type=volume_type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- delete_on_termination: Optional[bool] = None,
- iops: Optional[int] = None,
- throughput: Optional[int] = None,
- volume_size: Optional[int] = None,
- volume_type: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if delete_on_termination is None and 'deleteOnTermination' in kwargs:
- delete_on_termination = kwargs['deleteOnTermination']
- if volume_size is None and 'volumeSize' in kwargs:
- volume_size = kwargs['volumeSize']
- if volume_type is None and 'volumeType' in kwargs:
- volume_type = kwargs['volumeType']
-
if delete_on_termination is not None:
- _setter("delete_on_termination", delete_on_termination)
+ pulumi.set(__self__, "delete_on_termination", delete_on_termination)
if iops is not None:
- _setter("iops", iops)
+ pulumi.set(__self__, "iops", iops)
if throughput is not None:
- _setter("throughput", throughput)
+ pulumi.set(__self__, "throughput", throughput)
if volume_size is not None:
- _setter("volume_size", volume_size)
+ pulumi.set(__self__, "volume_size", volume_size)
if volume_type is not None:
- _setter("volume_type", volume_type)
+ pulumi.set(__self__, "volume_type", volume_type)
@property
@pulumi.getter(name="deleteOnTermination")
@@ -8315,51 +6255,18 @@ def __init__(__self__, *,
should_delete_snapshots: Optional[bool] = None,
should_delete_volumes: Optional[bool] = None,
should_terminate_instance: Optional[bool] = None):
- ManagedInstanceDelete._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- ami_backup_should_delete_images=ami_backup_should_delete_images,
- deallocation_config_should_delete_images=deallocation_config_should_delete_images,
- should_delete_network_interfaces=should_delete_network_interfaces,
- should_delete_snapshots=should_delete_snapshots,
- should_delete_volumes=should_delete_volumes,
- should_terminate_instance=should_terminate_instance,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- ami_backup_should_delete_images: Optional[bool] = None,
- deallocation_config_should_delete_images: Optional[bool] = None,
- should_delete_network_interfaces: Optional[bool] = None,
- should_delete_snapshots: Optional[bool] = None,
- should_delete_volumes: Optional[bool] = None,
- should_terminate_instance: Optional[bool] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if ami_backup_should_delete_images is None and 'amiBackupShouldDeleteImages' in kwargs:
- ami_backup_should_delete_images = kwargs['amiBackupShouldDeleteImages']
- if deallocation_config_should_delete_images is None and 'deallocationConfigShouldDeleteImages' in kwargs:
- deallocation_config_should_delete_images = kwargs['deallocationConfigShouldDeleteImages']
- if should_delete_network_interfaces is None and 'shouldDeleteNetworkInterfaces' in kwargs:
- should_delete_network_interfaces = kwargs['shouldDeleteNetworkInterfaces']
- if should_delete_snapshots is None and 'shouldDeleteSnapshots' in kwargs:
- should_delete_snapshots = kwargs['shouldDeleteSnapshots']
- if should_delete_volumes is None and 'shouldDeleteVolumes' in kwargs:
- should_delete_volumes = kwargs['shouldDeleteVolumes']
- if should_terminate_instance is None and 'shouldTerminateInstance' in kwargs:
- should_terminate_instance = kwargs['shouldTerminateInstance']
-
if ami_backup_should_delete_images is not None:
- _setter("ami_backup_should_delete_images", ami_backup_should_delete_images)
+ pulumi.set(__self__, "ami_backup_should_delete_images", ami_backup_should_delete_images)
if deallocation_config_should_delete_images is not None:
- _setter("deallocation_config_should_delete_images", deallocation_config_should_delete_images)
+ pulumi.set(__self__, "deallocation_config_should_delete_images", deallocation_config_should_delete_images)
if should_delete_network_interfaces is not None:
- _setter("should_delete_network_interfaces", should_delete_network_interfaces)
+ pulumi.set(__self__, "should_delete_network_interfaces", should_delete_network_interfaces)
if should_delete_snapshots is not None:
- _setter("should_delete_snapshots", should_delete_snapshots)
+ pulumi.set(__self__, "should_delete_snapshots", should_delete_snapshots)
if should_delete_volumes is not None:
- _setter("should_delete_volumes", should_delete_volumes)
+ pulumi.set(__self__, "should_delete_volumes", should_delete_volumes)
if should_terminate_instance is not None:
- _setter("should_terminate_instance", should_terminate_instance)
+ pulumi.set(__self__, "should_terminate_instance", should_terminate_instance)
@property
@pulumi.getter(name="amiBackupShouldDeleteImages")
@@ -8396,20 +6303,7 @@ def should_terminate_instance(self) -> Optional[bool]:
class ManagedInstanceIntegrationRoute53(dict):
def __init__(__self__, *,
domains: Sequence['outputs.ManagedInstanceIntegrationRoute53Domain']):
- ManagedInstanceIntegrationRoute53._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- domains=domains,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- domains: Optional[Sequence['outputs.ManagedInstanceIntegrationRoute53Domain']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if domains is None:
- raise TypeError("Missing 'domains' argument")
-
- _setter("domains", domains)
+ pulumi.set(__self__, "domains", domains)
@property
@pulumi.getter
@@ -8447,41 +6341,12 @@ def __init__(__self__, *,
record_sets: Sequence['outputs.ManagedInstanceIntegrationRoute53DomainRecordSet'],
record_set_type: Optional[str] = None,
spotinst_acct_id: Optional[str] = None):
- ManagedInstanceIntegrationRoute53Domain._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- hosted_zone_id=hosted_zone_id,
- record_sets=record_sets,
- record_set_type=record_set_type,
- spotinst_acct_id=spotinst_acct_id,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- hosted_zone_id: Optional[str] = None,
- record_sets: Optional[Sequence['outputs.ManagedInstanceIntegrationRoute53DomainRecordSet']] = None,
- record_set_type: Optional[str] = None,
- spotinst_acct_id: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if hosted_zone_id is None and 'hostedZoneId' in kwargs:
- hosted_zone_id = kwargs['hostedZoneId']
- if hosted_zone_id is None:
- raise TypeError("Missing 'hosted_zone_id' argument")
- if record_sets is None and 'recordSets' in kwargs:
- record_sets = kwargs['recordSets']
- if record_sets is None:
- raise TypeError("Missing 'record_sets' argument")
- if record_set_type is None and 'recordSetType' in kwargs:
- record_set_type = kwargs['recordSetType']
- if spotinst_acct_id is None and 'spotinstAcctId' in kwargs:
- spotinst_acct_id = kwargs['spotinstAcctId']
-
- _setter("hosted_zone_id", hosted_zone_id)
- _setter("record_sets", record_sets)
+ pulumi.set(__self__, "hosted_zone_id", hosted_zone_id)
+ pulumi.set(__self__, "record_sets", record_sets)
if record_set_type is not None:
- _setter("record_set_type", record_set_type)
+ pulumi.set(__self__, "record_set_type", record_set_type)
if spotinst_acct_id is not None:
- _setter("spotinst_acct_id", spotinst_acct_id)
+ pulumi.set(__self__, "spotinst_acct_id", spotinst_acct_id)
@property
@pulumi.getter(name="hostedZoneId")
@@ -8529,32 +6394,11 @@ def __init__(__self__, *,
name: str,
use_public_dns: Optional[bool] = None,
use_public_ip: Optional[bool] = None):
- ManagedInstanceIntegrationRoute53DomainRecordSet._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- use_public_dns=use_public_dns,
- use_public_ip=use_public_ip,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[str] = None,
- use_public_dns: Optional[bool] = None,
- use_public_ip: Optional[bool] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
- if use_public_dns is None and 'usePublicDns' in kwargs:
- use_public_dns = kwargs['usePublicDns']
- if use_public_ip is None and 'usePublicIp' in kwargs:
- use_public_ip = kwargs['usePublicIp']
-
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if use_public_dns is not None:
- _setter("use_public_dns", use_public_dns)
+ pulumi.set(__self__, "use_public_dns", use_public_dns)
if use_public_ip is not None:
- _setter("use_public_ip", use_public_ip)
+ pulumi.set(__self__, "use_public_ip", use_public_ip)
@property
@pulumi.getter
@@ -8605,52 +6449,19 @@ def __init__(__self__, *,
balancer_id: Optional[str] = None,
name: Optional[str] = None,
target_set_id: Optional[str] = None):
- ManagedInstanceLoadBalancer._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- type=type,
- arn=arn,
- auto_weight=auto_weight,
- az_awareness=az_awareness,
- balancer_id=balancer_id,
- name=name,
- target_set_id=target_set_id,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- type: Optional[str] = None,
- arn: Optional[str] = None,
- auto_weight: Optional[bool] = None,
- az_awareness: Optional[bool] = None,
- balancer_id: Optional[str] = None,
- name: Optional[str] = None,
- target_set_id: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if type is None:
- raise TypeError("Missing 'type' argument")
- if auto_weight is None and 'autoWeight' in kwargs:
- auto_weight = kwargs['autoWeight']
- if az_awareness is None and 'azAwareness' in kwargs:
- az_awareness = kwargs['azAwareness']
- if balancer_id is None and 'balancerId' in kwargs:
- balancer_id = kwargs['balancerId']
- if target_set_id is None and 'targetSetId' in kwargs:
- target_set_id = kwargs['targetSetId']
-
- _setter("type", type)
+ pulumi.set(__self__, "type", type)
if arn is not None:
- _setter("arn", arn)
+ pulumi.set(__self__, "arn", arn)
if auto_weight is not None:
- _setter("auto_weight", auto_weight)
+ pulumi.set(__self__, "auto_weight", auto_weight)
if az_awareness is not None:
- _setter("az_awareness", az_awareness)
+ pulumi.set(__self__, "az_awareness", az_awareness)
if balancer_id is not None:
- _setter("balancer_id", balancer_id)
+ pulumi.set(__self__, "balancer_id", balancer_id)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if target_set_id is not None:
- _setter("target_set_id", target_set_id)
+ pulumi.set(__self__, "target_set_id", target_set_id)
@property
@pulumi.getter
@@ -8692,20 +6503,7 @@ def target_set_id(self) -> Optional[str]:
class ManagedInstanceManagedInstanceAction(dict):
def __init__(__self__, *,
type: str):
- ManagedInstanceManagedInstanceAction._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- type=type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- type: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if type is None:
- raise TypeError("Missing 'type' argument")
-
- _setter("type", type)
+ pulumi.set(__self__, "type", type)
@property
@pulumi.getter
@@ -8740,34 +6538,11 @@ def __init__(__self__, *,
device_index: str,
associate_ipv6_address: Optional[bool] = None,
associate_public_ip_address: Optional[bool] = None):
- ManagedInstanceNetworkInterface._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- device_index=device_index,
- associate_ipv6_address=associate_ipv6_address,
- associate_public_ip_address=associate_public_ip_address,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- device_index: Optional[str] = None,
- associate_ipv6_address: Optional[bool] = None,
- associate_public_ip_address: Optional[bool] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if device_index is None and 'deviceIndex' in kwargs:
- device_index = kwargs['deviceIndex']
- if device_index is None:
- raise TypeError("Missing 'device_index' argument")
- if associate_ipv6_address is None and 'associateIpv6Address' in kwargs:
- associate_ipv6_address = kwargs['associateIpv6Address']
- if associate_public_ip_address is None and 'associatePublicIpAddress' in kwargs:
- associate_public_ip_address = kwargs['associatePublicIpAddress']
-
- _setter("device_index", device_index)
+ pulumi.set(__self__, "device_index", device_index)
if associate_ipv6_address is not None:
- _setter("associate_ipv6_address", associate_ipv6_address)
+ pulumi.set(__self__, "associate_ipv6_address", associate_ipv6_address)
if associate_public_ip_address is not None:
- _setter("associate_public_ip_address", associate_public_ip_address)
+ pulumi.set(__self__, "associate_public_ip_address", associate_public_ip_address)
@property
@pulumi.getter(name="deviceIndex")
@@ -8815,39 +6590,14 @@ def __init__(__self__, *,
should_tag_enis: Optional[bool] = None,
should_tag_snapshots: Optional[bool] = None,
should_tag_volumes: Optional[bool] = None):
- ManagedInstanceResourceTagSpecification._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- should_tag_amis=should_tag_amis,
- should_tag_enis=should_tag_enis,
- should_tag_snapshots=should_tag_snapshots,
- should_tag_volumes=should_tag_volumes,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- should_tag_amis: Optional[bool] = None,
- should_tag_enis: Optional[bool] = None,
- should_tag_snapshots: Optional[bool] = None,
- should_tag_volumes: Optional[bool] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if should_tag_amis is None and 'shouldTagAmis' in kwargs:
- should_tag_amis = kwargs['shouldTagAmis']
- if should_tag_enis is None and 'shouldTagEnis' in kwargs:
- should_tag_enis = kwargs['shouldTagEnis']
- if should_tag_snapshots is None and 'shouldTagSnapshots' in kwargs:
- should_tag_snapshots = kwargs['shouldTagSnapshots']
- if should_tag_volumes is None and 'shouldTagVolumes' in kwargs:
- should_tag_volumes = kwargs['shouldTagVolumes']
-
if should_tag_amis is not None:
- _setter("should_tag_amis", should_tag_amis)
+ pulumi.set(__self__, "should_tag_amis", should_tag_amis)
if should_tag_enis is not None:
- _setter("should_tag_enis", should_tag_enis)
+ pulumi.set(__self__, "should_tag_enis", should_tag_enis)
if should_tag_snapshots is not None:
- _setter("should_tag_snapshots", should_tag_snapshots)
+ pulumi.set(__self__, "should_tag_snapshots", should_tag_snapshots)
if should_tag_volumes is not None:
- _setter("should_tag_volumes", should_tag_volumes)
+ pulumi.set(__self__, "should_tag_volumes", should_tag_volumes)
@property
@pulumi.getter(name="shouldTagAmis")
@@ -8891,22 +6641,7 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
perform_at: str):
- ManagedInstanceRevertToSpot._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- perform_at=perform_at,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- perform_at: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if perform_at is None and 'performAt' in kwargs:
- perform_at = kwargs['performAt']
- if perform_at is None:
- raise TypeError("Missing 'perform_at' argument")
-
- _setter("perform_at", perform_at)
+ pulumi.set(__self__, "perform_at", perform_at)
@property
@pulumi.getter(name="performAt")
@@ -8945,44 +6680,15 @@ def __init__(__self__, *,
frequency: Optional[str] = None,
is_enabled: Optional[bool] = None,
start_time: Optional[str] = None):
- ManagedInstanceScheduledTask._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- task_type=task_type,
- cron_expression=cron_expression,
- frequency=frequency,
- is_enabled=is_enabled,
- start_time=start_time,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- task_type: Optional[str] = None,
- cron_expression: Optional[str] = None,
- frequency: Optional[str] = None,
- is_enabled: Optional[bool] = None,
- start_time: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if task_type is None and 'taskType' in kwargs:
- task_type = kwargs['taskType']
- if task_type is None:
- raise TypeError("Missing 'task_type' argument")
- if cron_expression is None and 'cronExpression' in kwargs:
- cron_expression = kwargs['cronExpression']
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
- if start_time is None and 'startTime' in kwargs:
- start_time = kwargs['startTime']
-
- _setter("task_type", task_type)
+ pulumi.set(__self__, "task_type", task_type)
if cron_expression is not None:
- _setter("cron_expression", cron_expression)
+ pulumi.set(__self__, "cron_expression", cron_expression)
if frequency is not None:
- _setter("frequency", frequency)
+ pulumi.set(__self__, "frequency", frequency)
if is_enabled is not None:
- _setter("is_enabled", is_enabled)
+ pulumi.set(__self__, "is_enabled", is_enabled)
if start_time is not None:
- _setter("start_time", start_time)
+ pulumi.set(__self__, "start_time", start_time)
@property
@pulumi.getter(name="taskType")
@@ -9015,23 +6721,10 @@ class ManagedInstanceTag(dict):
def __init__(__self__, *,
key: Optional[str] = None,
value: Optional[str] = None):
- ManagedInstanceTag._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if key is not None:
- _setter("key", key)
+ pulumi.set(__self__, "key", key)
if value is not None:
- _setter("value", value)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -9055,28 +6748,11 @@ def __init__(__self__, *,
:param Sequence[str] args: Arguments for EMR to pass to the application.
:param str version: T he version of the application.
"""
- MrScalarApplication._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- args=args,
- version=version,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[str] = None,
- args: Optional[Sequence[str]] = None,
- version: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
-
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if args is not None:
- _setter("args", args)
+ pulumi.set(__self__, "args", args)
if version is not None:
- _setter("version", version)
+ pulumi.set(__self__, "version", version)
@property
@pulumi.getter
@@ -9112,25 +6788,8 @@ def __init__(__self__, *,
:param str bucket: S3 Bucket name for bootstrap actions.
:param str key: S3 key for bootstrap actions.
"""
- MrScalarBootstrapActionsFile._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- bucket=bucket,
- key=key,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- bucket: Optional[str] = None,
- key: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if bucket is None:
- raise TypeError("Missing 'bucket' argument")
- if key is None:
- raise TypeError("Missing 'key' argument")
-
- _setter("bucket", bucket)
- _setter("key", key)
+ pulumi.set(__self__, "bucket", bucket)
+ pulumi.set(__self__, "key", key)
@property
@pulumi.getter
@@ -9158,25 +6817,8 @@ def __init__(__self__, *,
:param str bucket: S3 Bucket name for bootstrap actions.
:param str key: S3 key for bootstrap actions.
"""
- MrScalarConfigurationsFile._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- bucket=bucket,
- key=key,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- bucket: Optional[str] = None,
- key: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if bucket is None:
- raise TypeError("Missing 'bucket' argument")
- if key is None:
- raise TypeError("Missing 'key' argument")
-
- _setter("bucket", bucket)
- _setter("key", key)
+ pulumi.set(__self__, "bucket", bucket)
+ pulumi.set(__self__, "key", key)
@property
@pulumi.getter
@@ -9229,39 +6871,12 @@ def __init__(__self__, *,
:param int iops: IOPS for the volume. Required in some volume types, such as io1.
:param int volumes_per_instance: Amount of volumes per instance in the core group.
"""
- MrScalarCoreEbsBlockDevice._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- size_in_gb=size_in_gb,
- volume_type=volume_type,
- iops=iops,
- volumes_per_instance=volumes_per_instance,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- size_in_gb: Optional[int] = None,
- volume_type: Optional[str] = None,
- iops: Optional[int] = None,
- volumes_per_instance: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if size_in_gb is None and 'sizeInGb' in kwargs:
- size_in_gb = kwargs['sizeInGb']
- if size_in_gb is None:
- raise TypeError("Missing 'size_in_gb' argument")
- if volume_type is None and 'volumeType' in kwargs:
- volume_type = kwargs['volumeType']
- if volume_type is None:
- raise TypeError("Missing 'volume_type' argument")
- if volumes_per_instance is None and 'volumesPerInstance' in kwargs:
- volumes_per_instance = kwargs['volumesPerInstance']
-
- _setter("size_in_gb", size_in_gb)
- _setter("volume_type", volume_type)
+ pulumi.set(__self__, "size_in_gb", size_in_gb)
+ pulumi.set(__self__, "volume_type", volume_type)
if iops is not None:
- _setter("iops", iops)
+ pulumi.set(__self__, "iops", iops)
if volumes_per_instance is not None:
- _setter("volumes_per_instance", volumes_per_instance)
+ pulumi.set(__self__, "volumes_per_instance", volumes_per_instance)
@property
@pulumi.getter(name="sizeInGb")
@@ -9364,104 +6979,37 @@ def __init__(__self__, *,
:param str statistic: The aggregation method of the given metric. Valid Values: `average` | `sum` | `sampleCount` | `maximum` | `minimum`
:param str target: The number of instances to set when scale is needed.
"""
- MrScalarCoreScalingDownPolicy._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- metric_name=metric_name,
- namespace=namespace,
- policy_name=policy_name,
- threshold=threshold,
- unit=unit,
- action_type=action_type,
- adjustment=adjustment,
- cooldown=cooldown,
- dimensions=dimensions,
- evaluation_periods=evaluation_periods,
- max_target_capacity=max_target_capacity,
- maximum=maximum,
- min_target_capacity=min_target_capacity,
- minimum=minimum,
- operator=operator,
- period=period,
- statistic=statistic,
- target=target,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- metric_name: Optional[str] = None,
- namespace: Optional[str] = None,
- policy_name: Optional[str] = None,
- threshold: Optional[float] = None,
- unit: Optional[str] = None,
- action_type: Optional[str] = None,
- adjustment: Optional[str] = None,
- cooldown: Optional[int] = None,
- dimensions: Optional[Mapping[str, Any]] = None,
- evaluation_periods: Optional[int] = None,
- max_target_capacity: Optional[str] = None,
- maximum: Optional[str] = None,
- min_target_capacity: Optional[str] = None,
- minimum: Optional[str] = None,
- operator: Optional[str] = None,
- period: Optional[int] = None,
- statistic: Optional[str] = None,
- target: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if metric_name is None and 'metricName' in kwargs:
- metric_name = kwargs['metricName']
- if metric_name is None:
- raise TypeError("Missing 'metric_name' argument")
- if namespace is None:
- raise TypeError("Missing 'namespace' argument")
- if policy_name is None and 'policyName' in kwargs:
- policy_name = kwargs['policyName']
- if policy_name is None:
- raise TypeError("Missing 'policy_name' argument")
- if threshold is None:
- raise TypeError("Missing 'threshold' argument")
- if unit is None:
- raise TypeError("Missing 'unit' argument")
- if action_type is None and 'actionType' in kwargs:
- action_type = kwargs['actionType']
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
- if max_target_capacity is None and 'maxTargetCapacity' in kwargs:
- max_target_capacity = kwargs['maxTargetCapacity']
- if min_target_capacity is None and 'minTargetCapacity' in kwargs:
- min_target_capacity = kwargs['minTargetCapacity']
-
- _setter("metric_name", metric_name)
- _setter("namespace", namespace)
- _setter("policy_name", policy_name)
- _setter("threshold", threshold)
- _setter("unit", unit)
+ pulumi.set(__self__, "metric_name", metric_name)
+ pulumi.set(__self__, "namespace", namespace)
+ pulumi.set(__self__, "policy_name", policy_name)
+ pulumi.set(__self__, "threshold", threshold)
+ pulumi.set(__self__, "unit", unit)
if action_type is not None:
- _setter("action_type", action_type)
+ pulumi.set(__self__, "action_type", action_type)
if adjustment is not None:
- _setter("adjustment", adjustment)
+ pulumi.set(__self__, "adjustment", adjustment)
if cooldown is not None:
- _setter("cooldown", cooldown)
+ pulumi.set(__self__, "cooldown", cooldown)
if dimensions is not None:
- _setter("dimensions", dimensions)
+ pulumi.set(__self__, "dimensions", dimensions)
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
if max_target_capacity is not None:
- _setter("max_target_capacity", max_target_capacity)
+ pulumi.set(__self__, "max_target_capacity", max_target_capacity)
if maximum is not None:
- _setter("maximum", maximum)
+ pulumi.set(__self__, "maximum", maximum)
if min_target_capacity is not None:
- _setter("min_target_capacity", min_target_capacity)
+ pulumi.set(__self__, "min_target_capacity", min_target_capacity)
if minimum is not None:
- _setter("minimum", minimum)
+ pulumi.set(__self__, "minimum", minimum)
if operator is not None:
- _setter("operator", operator)
+ pulumi.set(__self__, "operator", operator)
if period is not None:
- _setter("period", period)
+ pulumi.set(__self__, "period", period)
if statistic is not None:
- _setter("statistic", statistic)
+ pulumi.set(__self__, "statistic", statistic)
if target is not None:
- _setter("target", target)
+ pulumi.set(__self__, "target", target)
@property
@pulumi.getter(name="metricName")
@@ -9676,104 +7224,37 @@ def __init__(__self__, *,
:param str statistic: The aggregation method of the given metric. Valid Values: `average` | `sum` | `sampleCount` | `maximum` | `minimum`
:param str target: The number of instances to set when scale is needed.
"""
- MrScalarCoreScalingUpPolicy._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- metric_name=metric_name,
- namespace=namespace,
- policy_name=policy_name,
- threshold=threshold,
- unit=unit,
- action_type=action_type,
- adjustment=adjustment,
- cooldown=cooldown,
- dimensions=dimensions,
- evaluation_periods=evaluation_periods,
- max_target_capacity=max_target_capacity,
- maximum=maximum,
- min_target_capacity=min_target_capacity,
- minimum=minimum,
- operator=operator,
- period=period,
- statistic=statistic,
- target=target,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- metric_name: Optional[str] = None,
- namespace: Optional[str] = None,
- policy_name: Optional[str] = None,
- threshold: Optional[float] = None,
- unit: Optional[str] = None,
- action_type: Optional[str] = None,
- adjustment: Optional[str] = None,
- cooldown: Optional[int] = None,
- dimensions: Optional[Mapping[str, Any]] = None,
- evaluation_periods: Optional[int] = None,
- max_target_capacity: Optional[str] = None,
- maximum: Optional[str] = None,
- min_target_capacity: Optional[str] = None,
- minimum: Optional[str] = None,
- operator: Optional[str] = None,
- period: Optional[int] = None,
- statistic: Optional[str] = None,
- target: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if metric_name is None and 'metricName' in kwargs:
- metric_name = kwargs['metricName']
- if metric_name is None:
- raise TypeError("Missing 'metric_name' argument")
- if namespace is None:
- raise TypeError("Missing 'namespace' argument")
- if policy_name is None and 'policyName' in kwargs:
- policy_name = kwargs['policyName']
- if policy_name is None:
- raise TypeError("Missing 'policy_name' argument")
- if threshold is None:
- raise TypeError("Missing 'threshold' argument")
- if unit is None:
- raise TypeError("Missing 'unit' argument")
- if action_type is None and 'actionType' in kwargs:
- action_type = kwargs['actionType']
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
- if max_target_capacity is None and 'maxTargetCapacity' in kwargs:
- max_target_capacity = kwargs['maxTargetCapacity']
- if min_target_capacity is None and 'minTargetCapacity' in kwargs:
- min_target_capacity = kwargs['minTargetCapacity']
-
- _setter("metric_name", metric_name)
- _setter("namespace", namespace)
- _setter("policy_name", policy_name)
- _setter("threshold", threshold)
- _setter("unit", unit)
+ pulumi.set(__self__, "metric_name", metric_name)
+ pulumi.set(__self__, "namespace", namespace)
+ pulumi.set(__self__, "policy_name", policy_name)
+ pulumi.set(__self__, "threshold", threshold)
+ pulumi.set(__self__, "unit", unit)
if action_type is not None:
- _setter("action_type", action_type)
+ pulumi.set(__self__, "action_type", action_type)
if adjustment is not None:
- _setter("adjustment", adjustment)
+ pulumi.set(__self__, "adjustment", adjustment)
if cooldown is not None:
- _setter("cooldown", cooldown)
+ pulumi.set(__self__, "cooldown", cooldown)
if dimensions is not None:
- _setter("dimensions", dimensions)
+ pulumi.set(__self__, "dimensions", dimensions)
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
if max_target_capacity is not None:
- _setter("max_target_capacity", max_target_capacity)
+ pulumi.set(__self__, "max_target_capacity", max_target_capacity)
if maximum is not None:
- _setter("maximum", maximum)
+ pulumi.set(__self__, "maximum", maximum)
if min_target_capacity is not None:
- _setter("min_target_capacity", min_target_capacity)
+ pulumi.set(__self__, "min_target_capacity", min_target_capacity)
if minimum is not None:
- _setter("minimum", minimum)
+ pulumi.set(__self__, "minimum", minimum)
if operator is not None:
- _setter("operator", operator)
+ pulumi.set(__self__, "operator", operator)
if period is not None:
- _setter("period", period)
+ pulumi.set(__self__, "period", period)
if statistic is not None:
- _setter("statistic", statistic)
+ pulumi.set(__self__, "statistic", statistic)
if target is not None:
- _setter("target", target)
+ pulumi.set(__self__, "target", target)
@property
@pulumi.getter(name="metricName")
@@ -9948,29 +7429,8 @@ def __init__(__self__, *,
:param str instance_type: The type of the instance.
:param int weighted_capacity: The weight given to the associated instance type.
"""
- MrScalarInstanceWeight._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- instance_type=instance_type,
- weighted_capacity=weighted_capacity,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- instance_type: Optional[str] = None,
- weighted_capacity: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if instance_type is None and 'instanceType' in kwargs:
- instance_type = kwargs['instanceType']
- if instance_type is None:
- raise TypeError("Missing 'instance_type' argument")
- if weighted_capacity is None and 'weightedCapacity' in kwargs:
- weighted_capacity = kwargs['weightedCapacity']
- if weighted_capacity is None:
- raise TypeError("Missing 'weighted_capacity' argument")
-
- _setter("instance_type", instance_type)
- _setter("weighted_capacity", weighted_capacity)
+ pulumi.set(__self__, "instance_type", instance_type)
+ pulumi.set(__self__, "weighted_capacity", weighted_capacity)
@property
@pulumi.getter(name="instanceType")
@@ -10023,39 +7483,12 @@ def __init__(__self__, *,
:param int iops: IOPS for the volume. Required in some volume types, such as io1.
:param int volumes_per_instance: Amount of volumes per instance in the core group.
"""
- MrScalarMasterEbsBlockDevice._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- size_in_gb=size_in_gb,
- volume_type=volume_type,
- iops=iops,
- volumes_per_instance=volumes_per_instance,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- size_in_gb: Optional[int] = None,
- volume_type: Optional[str] = None,
- iops: Optional[int] = None,
- volumes_per_instance: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if size_in_gb is None and 'sizeInGb' in kwargs:
- size_in_gb = kwargs['sizeInGb']
- if size_in_gb is None:
- raise TypeError("Missing 'size_in_gb' argument")
- if volume_type is None and 'volumeType' in kwargs:
- volume_type = kwargs['volumeType']
- if volume_type is None:
- raise TypeError("Missing 'volume_type' argument")
- if volumes_per_instance is None and 'volumesPerInstance' in kwargs:
- volumes_per_instance = kwargs['volumesPerInstance']
-
- _setter("size_in_gb", size_in_gb)
- _setter("volume_type", volume_type)
+ pulumi.set(__self__, "size_in_gb", size_in_gb)
+ pulumi.set(__self__, "volume_type", volume_type)
if iops is not None:
- _setter("iops", iops)
+ pulumi.set(__self__, "iops", iops)
if volumes_per_instance is not None:
- _setter("volumes_per_instance", volumes_per_instance)
+ pulumi.set(__self__, "volumes_per_instance", volumes_per_instance)
@property
@pulumi.getter(name="sizeInGb")
@@ -10116,27 +7549,8 @@ def __init__(__self__, *,
:param int timeout: The amount of time (minutes) after which the cluster is automatically terminated if it's still in provisioning status. Minimum: '15'.
:param str timeout_action: The action to take if the timeout is exceeded. Valid values: `terminate`, `terminateAndRetry`.
"""
- MrScalarProvisioningTimeout._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- timeout=timeout,
- timeout_action=timeout_action,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- timeout: Optional[int] = None,
- timeout_action: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if timeout is None:
- raise TypeError("Missing 'timeout' argument")
- if timeout_action is None and 'timeoutAction' in kwargs:
- timeout_action = kwargs['timeoutAction']
- if timeout_action is None:
- raise TypeError("Missing 'timeout_action' argument")
-
- _setter("timeout", timeout)
- _setter("timeout_action", timeout_action)
+ pulumi.set(__self__, "timeout", timeout)
+ pulumi.set(__self__, "timeout_action", timeout_action)
@property
@pulumi.getter
@@ -10201,58 +7615,17 @@ def __init__(__self__, *,
:param str max_capacity: New max capacity for the elastigroup.
:param str min_capacity: New min capacity for the elastigroup.
"""
- MrScalarScheduledTask._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cron=cron,
- instance_group_type=instance_group_type,
- task_type=task_type,
- desired_capacity=desired_capacity,
- is_enabled=is_enabled,
- max_capacity=max_capacity,
- min_capacity=min_capacity,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cron: Optional[str] = None,
- instance_group_type: Optional[str] = None,
- task_type: Optional[str] = None,
- desired_capacity: Optional[str] = None,
- is_enabled: Optional[bool] = None,
- max_capacity: Optional[str] = None,
- min_capacity: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cron is None:
- raise TypeError("Missing 'cron' argument")
- if instance_group_type is None and 'instanceGroupType' in kwargs:
- instance_group_type = kwargs['instanceGroupType']
- if instance_group_type is None:
- raise TypeError("Missing 'instance_group_type' argument")
- if task_type is None and 'taskType' in kwargs:
- task_type = kwargs['taskType']
- if task_type is None:
- raise TypeError("Missing 'task_type' argument")
- if desired_capacity is None and 'desiredCapacity' in kwargs:
- desired_capacity = kwargs['desiredCapacity']
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
- if max_capacity is None and 'maxCapacity' in kwargs:
- max_capacity = kwargs['maxCapacity']
- if min_capacity is None and 'minCapacity' in kwargs:
- min_capacity = kwargs['minCapacity']
-
- _setter("cron", cron)
- _setter("instance_group_type", instance_group_type)
- _setter("task_type", task_type)
+ pulumi.set(__self__, "cron", cron)
+ pulumi.set(__self__, "instance_group_type", instance_group_type)
+ pulumi.set(__self__, "task_type", task_type)
if desired_capacity is not None:
- _setter("desired_capacity", desired_capacity)
+ pulumi.set(__self__, "desired_capacity", desired_capacity)
if is_enabled is not None:
- _setter("is_enabled", is_enabled)
+ pulumi.set(__self__, "is_enabled", is_enabled)
if max_capacity is not None:
- _setter("max_capacity", max_capacity)
+ pulumi.set(__self__, "max_capacity", max_capacity)
if min_capacity is not None:
- _setter("min_capacity", min_capacity)
+ pulumi.set(__self__, "min_capacity", min_capacity)
@property
@pulumi.getter
@@ -10320,25 +7693,8 @@ def __init__(__self__, *,
:param str bucket: S3 Bucket name for bootstrap actions.
:param str key: S3 key for bootstrap actions.
"""
- MrScalarStepsFile._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- bucket=bucket,
- key=key,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- bucket: Optional[str] = None,
- key: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if bucket is None:
- raise TypeError("Missing 'bucket' argument")
- if key is None:
- raise TypeError("Missing 'key' argument")
-
- _setter("bucket", bucket)
- _setter("key", key)
+ pulumi.set(__self__, "bucket", bucket)
+ pulumi.set(__self__, "key", key)
@property
@pulumi.getter
@@ -10366,25 +7722,8 @@ def __init__(__self__, *,
:param str key: S3 key for bootstrap actions.
:param str value: Tag value.
"""
- MrScalarTag._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -10437,39 +7776,12 @@ def __init__(__self__, *,
:param int iops: IOPS for the volume. Required in some volume types, such as io1.
:param int volumes_per_instance: Amount of volumes per instance in the core group.
"""
- MrScalarTaskEbsBlockDevice._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- size_in_gb=size_in_gb,
- volume_type=volume_type,
- iops=iops,
- volumes_per_instance=volumes_per_instance,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- size_in_gb: Optional[int] = None,
- volume_type: Optional[str] = None,
- iops: Optional[int] = None,
- volumes_per_instance: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if size_in_gb is None and 'sizeInGb' in kwargs:
- size_in_gb = kwargs['sizeInGb']
- if size_in_gb is None:
- raise TypeError("Missing 'size_in_gb' argument")
- if volume_type is None and 'volumeType' in kwargs:
- volume_type = kwargs['volumeType']
- if volume_type is None:
- raise TypeError("Missing 'volume_type' argument")
- if volumes_per_instance is None and 'volumesPerInstance' in kwargs:
- volumes_per_instance = kwargs['volumesPerInstance']
-
- _setter("size_in_gb", size_in_gb)
- _setter("volume_type", volume_type)
+ pulumi.set(__self__, "size_in_gb", size_in_gb)
+ pulumi.set(__self__, "volume_type", volume_type)
if iops is not None:
- _setter("iops", iops)
+ pulumi.set(__self__, "iops", iops)
if volumes_per_instance is not None:
- _setter("volumes_per_instance", volumes_per_instance)
+ pulumi.set(__self__, "volumes_per_instance", volumes_per_instance)
@property
@pulumi.getter(name="sizeInGb")
@@ -10572,104 +7884,37 @@ def __init__(__self__, *,
:param str statistic: The aggregation method of the given metric. Valid Values: `average` | `sum` | `sampleCount` | `maximum` | `minimum`
:param str target: The number of instances to set when scale is needed.
"""
- MrScalarTaskScalingDownPolicy._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- metric_name=metric_name,
- namespace=namespace,
- policy_name=policy_name,
- threshold=threshold,
- unit=unit,
- action_type=action_type,
- adjustment=adjustment,
- cooldown=cooldown,
- dimensions=dimensions,
- evaluation_periods=evaluation_periods,
- max_target_capacity=max_target_capacity,
- maximum=maximum,
- min_target_capacity=min_target_capacity,
- minimum=minimum,
- operator=operator,
- period=period,
- statistic=statistic,
- target=target,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- metric_name: Optional[str] = None,
- namespace: Optional[str] = None,
- policy_name: Optional[str] = None,
- threshold: Optional[float] = None,
- unit: Optional[str] = None,
- action_type: Optional[str] = None,
- adjustment: Optional[str] = None,
- cooldown: Optional[int] = None,
- dimensions: Optional[Mapping[str, Any]] = None,
- evaluation_periods: Optional[int] = None,
- max_target_capacity: Optional[str] = None,
- maximum: Optional[str] = None,
- min_target_capacity: Optional[str] = None,
- minimum: Optional[str] = None,
- operator: Optional[str] = None,
- period: Optional[int] = None,
- statistic: Optional[str] = None,
- target: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if metric_name is None and 'metricName' in kwargs:
- metric_name = kwargs['metricName']
- if metric_name is None:
- raise TypeError("Missing 'metric_name' argument")
- if namespace is None:
- raise TypeError("Missing 'namespace' argument")
- if policy_name is None and 'policyName' in kwargs:
- policy_name = kwargs['policyName']
- if policy_name is None:
- raise TypeError("Missing 'policy_name' argument")
- if threshold is None:
- raise TypeError("Missing 'threshold' argument")
- if unit is None:
- raise TypeError("Missing 'unit' argument")
- if action_type is None and 'actionType' in kwargs:
- action_type = kwargs['actionType']
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
- if max_target_capacity is None and 'maxTargetCapacity' in kwargs:
- max_target_capacity = kwargs['maxTargetCapacity']
- if min_target_capacity is None and 'minTargetCapacity' in kwargs:
- min_target_capacity = kwargs['minTargetCapacity']
-
- _setter("metric_name", metric_name)
- _setter("namespace", namespace)
- _setter("policy_name", policy_name)
- _setter("threshold", threshold)
- _setter("unit", unit)
+ pulumi.set(__self__, "metric_name", metric_name)
+ pulumi.set(__self__, "namespace", namespace)
+ pulumi.set(__self__, "policy_name", policy_name)
+ pulumi.set(__self__, "threshold", threshold)
+ pulumi.set(__self__, "unit", unit)
if action_type is not None:
- _setter("action_type", action_type)
+ pulumi.set(__self__, "action_type", action_type)
if adjustment is not None:
- _setter("adjustment", adjustment)
+ pulumi.set(__self__, "adjustment", adjustment)
if cooldown is not None:
- _setter("cooldown", cooldown)
+ pulumi.set(__self__, "cooldown", cooldown)
if dimensions is not None:
- _setter("dimensions", dimensions)
+ pulumi.set(__self__, "dimensions", dimensions)
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
if max_target_capacity is not None:
- _setter("max_target_capacity", max_target_capacity)
+ pulumi.set(__self__, "max_target_capacity", max_target_capacity)
if maximum is not None:
- _setter("maximum", maximum)
+ pulumi.set(__self__, "maximum", maximum)
if min_target_capacity is not None:
- _setter("min_target_capacity", min_target_capacity)
+ pulumi.set(__self__, "min_target_capacity", min_target_capacity)
if minimum is not None:
- _setter("minimum", minimum)
+ pulumi.set(__self__, "minimum", minimum)
if operator is not None:
- _setter("operator", operator)
+ pulumi.set(__self__, "operator", operator)
if period is not None:
- _setter("period", period)
+ pulumi.set(__self__, "period", period)
if statistic is not None:
- _setter("statistic", statistic)
+ pulumi.set(__self__, "statistic", statistic)
if target is not None:
- _setter("target", target)
+ pulumi.set(__self__, "target", target)
@property
@pulumi.getter(name="metricName")
@@ -10884,104 +8129,37 @@ def __init__(__self__, *,
:param str statistic: The aggregation method of the given metric. Valid Values: `average` | `sum` | `sampleCount` | `maximum` | `minimum`
:param str target: The number of instances to set when scale is needed.
"""
- MrScalarTaskScalingUpPolicy._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- metric_name=metric_name,
- namespace=namespace,
- policy_name=policy_name,
- threshold=threshold,
- unit=unit,
- action_type=action_type,
- adjustment=adjustment,
- cooldown=cooldown,
- dimensions=dimensions,
- evaluation_periods=evaluation_periods,
- max_target_capacity=max_target_capacity,
- maximum=maximum,
- min_target_capacity=min_target_capacity,
- minimum=minimum,
- operator=operator,
- period=period,
- statistic=statistic,
- target=target,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- metric_name: Optional[str] = None,
- namespace: Optional[str] = None,
- policy_name: Optional[str] = None,
- threshold: Optional[float] = None,
- unit: Optional[str] = None,
- action_type: Optional[str] = None,
- adjustment: Optional[str] = None,
- cooldown: Optional[int] = None,
- dimensions: Optional[Mapping[str, Any]] = None,
- evaluation_periods: Optional[int] = None,
- max_target_capacity: Optional[str] = None,
- maximum: Optional[str] = None,
- min_target_capacity: Optional[str] = None,
- minimum: Optional[str] = None,
- operator: Optional[str] = None,
- period: Optional[int] = None,
- statistic: Optional[str] = None,
- target: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if metric_name is None and 'metricName' in kwargs:
- metric_name = kwargs['metricName']
- if metric_name is None:
- raise TypeError("Missing 'metric_name' argument")
- if namespace is None:
- raise TypeError("Missing 'namespace' argument")
- if policy_name is None and 'policyName' in kwargs:
- policy_name = kwargs['policyName']
- if policy_name is None:
- raise TypeError("Missing 'policy_name' argument")
- if threshold is None:
- raise TypeError("Missing 'threshold' argument")
- if unit is None:
- raise TypeError("Missing 'unit' argument")
- if action_type is None and 'actionType' in kwargs:
- action_type = kwargs['actionType']
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
- if max_target_capacity is None and 'maxTargetCapacity' in kwargs:
- max_target_capacity = kwargs['maxTargetCapacity']
- if min_target_capacity is None and 'minTargetCapacity' in kwargs:
- min_target_capacity = kwargs['minTargetCapacity']
-
- _setter("metric_name", metric_name)
- _setter("namespace", namespace)
- _setter("policy_name", policy_name)
- _setter("threshold", threshold)
- _setter("unit", unit)
+ pulumi.set(__self__, "metric_name", metric_name)
+ pulumi.set(__self__, "namespace", namespace)
+ pulumi.set(__self__, "policy_name", policy_name)
+ pulumi.set(__self__, "threshold", threshold)
+ pulumi.set(__self__, "unit", unit)
if action_type is not None:
- _setter("action_type", action_type)
+ pulumi.set(__self__, "action_type", action_type)
if adjustment is not None:
- _setter("adjustment", adjustment)
+ pulumi.set(__self__, "adjustment", adjustment)
if cooldown is not None:
- _setter("cooldown", cooldown)
+ pulumi.set(__self__, "cooldown", cooldown)
if dimensions is not None:
- _setter("dimensions", dimensions)
+ pulumi.set(__self__, "dimensions", dimensions)
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
if max_target_capacity is not None:
- _setter("max_target_capacity", max_target_capacity)
+ pulumi.set(__self__, "max_target_capacity", max_target_capacity)
if maximum is not None:
- _setter("maximum", maximum)
+ pulumi.set(__self__, "maximum", maximum)
if min_target_capacity is not None:
- _setter("min_target_capacity", min_target_capacity)
+ pulumi.set(__self__, "min_target_capacity", min_target_capacity)
if minimum is not None:
- _setter("minimum", minimum)
+ pulumi.set(__self__, "minimum", minimum)
if operator is not None:
- _setter("operator", operator)
+ pulumi.set(__self__, "operator", operator)
if period is not None:
- _setter("period", period)
+ pulumi.set(__self__, "period", period)
if statistic is not None:
- _setter("statistic", statistic)
+ pulumi.set(__self__, "statistic", statistic)
if target is not None:
- _setter("target", target)
+ pulumi.set(__self__, "target", target)
@property
@pulumi.getter(name="metricName")
@@ -11132,20 +8310,7 @@ def target(self) -> Optional[str]:
class MrScalarTerminationPolicy(dict):
def __init__(__self__, *,
statements: Sequence['outputs.MrScalarTerminationPolicyStatement']):
- MrScalarTerminationPolicy._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- statements=statements,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- statements: Optional[Sequence['outputs.MrScalarTerminationPolicyStatement']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if statements is None:
- raise TypeError("Missing 'statements' argument")
-
- _setter("statements", statements)
+ pulumi.set(__self__, "statements", statements)
@property
@pulumi.getter
@@ -11193,54 +8358,19 @@ def __init__(__self__, *,
:param str statistic: The aggregation method of the given metric. Valid Values: `average` | `sum` | `sampleCount` | `maximum` | `minimum`
:param str unit: The unit for a given metric. Valid Values: `seconds` | `microseconds` | `milliseconds` | `bytes` | `kilobytes` | `megabytes` | `gigabytes` | `terabytes` | `bits` | `kilobits` | `megabits` | `gigabits` | `terabits` | `percent` | `count` | `bytes/second` | `kilobytes/second` | `megabytes/second` | `gigabytes/second` | `terabytes/second` | `bits/second` | `kilobits/second` | `megabits/second` | `gigabits/second` | `terabits/second` | `count/second` | `none`
"""
- MrScalarTerminationPolicyStatement._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- metric_name=metric_name,
- namespace=namespace,
- threshold=threshold,
- evaluation_periods=evaluation_periods,
- operator=operator,
- period=period,
- statistic=statistic,
- unit=unit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- metric_name: Optional[str] = None,
- namespace: Optional[str] = None,
- threshold: Optional[float] = None,
- evaluation_periods: Optional[int] = None,
- operator: Optional[str] = None,
- period: Optional[int] = None,
- statistic: Optional[str] = None,
- unit: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if metric_name is None and 'metricName' in kwargs:
- metric_name = kwargs['metricName']
- if metric_name is None:
- raise TypeError("Missing 'metric_name' argument")
- if namespace is None:
- raise TypeError("Missing 'namespace' argument")
- if threshold is None:
- raise TypeError("Missing 'threshold' argument")
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
-
- _setter("metric_name", metric_name)
- _setter("namespace", namespace)
- _setter("threshold", threshold)
+ pulumi.set(__self__, "metric_name", metric_name)
+ pulumi.set(__self__, "namespace", namespace)
+ pulumi.set(__self__, "threshold", threshold)
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
if operator is not None:
- _setter("operator", operator)
+ pulumi.set(__self__, "operator", operator)
if period is not None:
- _setter("period", period)
+ pulumi.set(__self__, "period", period)
if statistic is not None:
- _setter("statistic", statistic)
+ pulumi.set(__self__, "statistic", statistic)
if unit is not None:
- _setter("unit", unit)
+ pulumi.set(__self__, "unit", unit)
@property
@pulumi.getter(name="metricName")
@@ -11352,69 +8482,24 @@ def __init__(__self__, *,
enable_automatic_and_manual_headroom: Optional[bool] = None,
extended_resource_definitions: Optional[Sequence[str]] = None,
resource_limits: Optional['outputs.OceanAutoscalerResourceLimits'] = None):
- OceanAutoscaler._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- auto_headroom_percentage=auto_headroom_percentage,
- autoscale_cooldown=autoscale_cooldown,
- autoscale_down=autoscale_down,
- autoscale_headroom=autoscale_headroom,
- autoscale_is_auto_config=autoscale_is_auto_config,
- autoscale_is_enabled=autoscale_is_enabled,
- enable_automatic_and_manual_headroom=enable_automatic_and_manual_headroom,
- extended_resource_definitions=extended_resource_definitions,
- resource_limits=resource_limits,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- auto_headroom_percentage: Optional[int] = None,
- autoscale_cooldown: Optional[int] = None,
- autoscale_down: Optional['outputs.OceanAutoscalerAutoscaleDown'] = None,
- autoscale_headroom: Optional['outputs.OceanAutoscalerAutoscaleHeadroom'] = None,
- autoscale_is_auto_config: Optional[bool] = None,
- autoscale_is_enabled: Optional[bool] = None,
- enable_automatic_and_manual_headroom: Optional[bool] = None,
- extended_resource_definitions: Optional[Sequence[str]] = None,
- resource_limits: Optional['outputs.OceanAutoscalerResourceLimits'] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if auto_headroom_percentage is None and 'autoHeadroomPercentage' in kwargs:
- auto_headroom_percentage = kwargs['autoHeadroomPercentage']
- if autoscale_cooldown is None and 'autoscaleCooldown' in kwargs:
- autoscale_cooldown = kwargs['autoscaleCooldown']
- if autoscale_down is None and 'autoscaleDown' in kwargs:
- autoscale_down = kwargs['autoscaleDown']
- if autoscale_headroom is None and 'autoscaleHeadroom' in kwargs:
- autoscale_headroom = kwargs['autoscaleHeadroom']
- if autoscale_is_auto_config is None and 'autoscaleIsAutoConfig' in kwargs:
- autoscale_is_auto_config = kwargs['autoscaleIsAutoConfig']
- if autoscale_is_enabled is None and 'autoscaleIsEnabled' in kwargs:
- autoscale_is_enabled = kwargs['autoscaleIsEnabled']
- if enable_automatic_and_manual_headroom is None and 'enableAutomaticAndManualHeadroom' in kwargs:
- enable_automatic_and_manual_headroom = kwargs['enableAutomaticAndManualHeadroom']
- if extended_resource_definitions is None and 'extendedResourceDefinitions' in kwargs:
- extended_resource_definitions = kwargs['extendedResourceDefinitions']
- if resource_limits is None and 'resourceLimits' in kwargs:
- resource_limits = kwargs['resourceLimits']
-
if auto_headroom_percentage is not None:
- _setter("auto_headroom_percentage", auto_headroom_percentage)
+ pulumi.set(__self__, "auto_headroom_percentage", auto_headroom_percentage)
if autoscale_cooldown is not None:
- _setter("autoscale_cooldown", autoscale_cooldown)
+ pulumi.set(__self__, "autoscale_cooldown", autoscale_cooldown)
if autoscale_down is not None:
- _setter("autoscale_down", autoscale_down)
+ pulumi.set(__self__, "autoscale_down", autoscale_down)
if autoscale_headroom is not None:
- _setter("autoscale_headroom", autoscale_headroom)
+ pulumi.set(__self__, "autoscale_headroom", autoscale_headroom)
if autoscale_is_auto_config is not None:
- _setter("autoscale_is_auto_config", autoscale_is_auto_config)
+ pulumi.set(__self__, "autoscale_is_auto_config", autoscale_is_auto_config)
if autoscale_is_enabled is not None:
- _setter("autoscale_is_enabled", autoscale_is_enabled)
+ pulumi.set(__self__, "autoscale_is_enabled", autoscale_is_enabled)
if enable_automatic_and_manual_headroom is not None:
- _setter("enable_automatic_and_manual_headroom", enable_automatic_and_manual_headroom)
+ pulumi.set(__self__, "enable_automatic_and_manual_headroom", enable_automatic_and_manual_headroom)
if extended_resource_definitions is not None:
- _setter("extended_resource_definitions", extended_resource_definitions)
+ pulumi.set(__self__, "extended_resource_definitions", extended_resource_definitions)
if resource_limits is not None:
- _setter("resource_limits", resource_limits)
+ pulumi.set(__self__, "resource_limits", resource_limits)
@property
@pulumi.getter(name="autoHeadroomPercentage")
@@ -11486,27 +8571,10 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
evaluation_periods: Optional[int] = None,
max_scale_down_percentage: Optional[float] = None):
- OceanAutoscalerAutoscaleDown._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- evaluation_periods=evaluation_periods,
- max_scale_down_percentage=max_scale_down_percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- evaluation_periods: Optional[int] = None,
- max_scale_down_percentage: Optional[float] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
- if max_scale_down_percentage is None and 'maxScaleDownPercentage' in kwargs:
- max_scale_down_percentage = kwargs['maxScaleDownPercentage']
-
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
if max_scale_down_percentage is not None:
- _setter("max_scale_down_percentage", max_scale_down_percentage)
+ pulumi.set(__self__, "max_scale_down_percentage", max_scale_down_percentage)
@property
@pulumi.getter(name="evaluationPeriods")
@@ -11549,39 +8617,14 @@ def __init__(__self__, *,
gpu_per_unit: Optional[int] = None,
memory_per_unit: Optional[int] = None,
num_of_units: Optional[int] = None):
- OceanAutoscalerAutoscaleHeadroom._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cpu_per_unit=cpu_per_unit,
- gpu_per_unit=gpu_per_unit,
- memory_per_unit=memory_per_unit,
- num_of_units=num_of_units,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cpu_per_unit: Optional[int] = None,
- gpu_per_unit: Optional[int] = None,
- memory_per_unit: Optional[int] = None,
- num_of_units: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cpu_per_unit is None and 'cpuPerUnit' in kwargs:
- cpu_per_unit = kwargs['cpuPerUnit']
- if gpu_per_unit is None and 'gpuPerUnit' in kwargs:
- gpu_per_unit = kwargs['gpuPerUnit']
- if memory_per_unit is None and 'memoryPerUnit' in kwargs:
- memory_per_unit = kwargs['memoryPerUnit']
- if num_of_units is None and 'numOfUnits' in kwargs:
- num_of_units = kwargs['numOfUnits']
-
if cpu_per_unit is not None:
- _setter("cpu_per_unit", cpu_per_unit)
+ pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
if gpu_per_unit is not None:
- _setter("gpu_per_unit", gpu_per_unit)
+ pulumi.set(__self__, "gpu_per_unit", gpu_per_unit)
if memory_per_unit is not None:
- _setter("memory_per_unit", memory_per_unit)
+ pulumi.set(__self__, "memory_per_unit", memory_per_unit)
if num_of_units is not None:
- _setter("num_of_units", num_of_units)
+ pulumi.set(__self__, "num_of_units", num_of_units)
@property
@pulumi.getter(name="cpuPerUnit")
@@ -11632,27 +8675,10 @@ def __init__(__self__, *,
:param int max_memory_gib: Maximum amount of Memory (GiB).
:param int max_vcpu: Maximum number of vcpus available.
"""
- OceanAutoscalerResourceLimits._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- max_memory_gib=max_memory_gib,
- max_vcpu=max_vcpu,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- max_memory_gib: Optional[int] = None,
- max_vcpu: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if max_memory_gib is None and 'maxMemoryGib' in kwargs:
- max_memory_gib = kwargs['maxMemoryGib']
- if max_vcpu is None and 'maxVcpu' in kwargs:
- max_vcpu = kwargs['maxVcpu']
-
if max_memory_gib is not None:
- _setter("max_memory_gib", max_memory_gib)
+ pulumi.set(__self__, "max_memory_gib", max_memory_gib)
if max_vcpu is not None:
- _setter("max_vcpu", max_vcpu)
+ pulumi.set(__self__, "max_vcpu", max_vcpu)
@property
@pulumi.getter(name="maxMemoryGib")
@@ -11697,25 +8723,10 @@ def __init__(__self__, *,
:param str device_name: String. Set device name. (Example: `/dev/xvda`).
:param 'OceanBlockDeviceMappingEbsArgs' ebs: Object. Set Elastic Block Store properties .
"""
- OceanBlockDeviceMapping._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- device_name=device_name,
- ebs=ebs,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- device_name: Optional[str] = None,
- ebs: Optional['outputs.OceanBlockDeviceMappingEbs'] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if device_name is None and 'deviceName' in kwargs:
- device_name = kwargs['deviceName']
-
if device_name is not None:
- _setter("device_name", device_name)
+ pulumi.set(__self__, "device_name", device_name)
if ebs is not None:
- _setter("ebs", ebs)
+ pulumi.set(__self__, "ebs", ebs)
@property
@pulumi.getter(name="deviceName")
@@ -11788,69 +8799,26 @@ def __init__(__self__, *,
:param int volume_size: Int. The size, in GB of the volume.
:param str volume_type: String. The type of the volume. (Example: `gp2`).
"""
- OceanBlockDeviceMappingEbs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- delete_on_termination=delete_on_termination,
- dynamic_iops=dynamic_iops,
- dynamic_volume_size=dynamic_volume_size,
- encrypted=encrypted,
- iops=iops,
- kms_key_id=kms_key_id,
- snapshot_id=snapshot_id,
- throughput=throughput,
- volume_size=volume_size,
- volume_type=volume_type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- delete_on_termination: Optional[bool] = None,
- dynamic_iops: Optional['outputs.OceanBlockDeviceMappingEbsDynamicIops'] = None,
- dynamic_volume_size: Optional['outputs.OceanBlockDeviceMappingEbsDynamicVolumeSize'] = None,
- encrypted: Optional[bool] = None,
- iops: Optional[int] = None,
- kms_key_id: Optional[str] = None,
- snapshot_id: Optional[str] = None,
- throughput: Optional[int] = None,
- volume_size: Optional[int] = None,
- volume_type: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if delete_on_termination is None and 'deleteOnTermination' in kwargs:
- delete_on_termination = kwargs['deleteOnTermination']
- if dynamic_iops is None and 'dynamicIops' in kwargs:
- dynamic_iops = kwargs['dynamicIops']
- if dynamic_volume_size is None and 'dynamicVolumeSize' in kwargs:
- dynamic_volume_size = kwargs['dynamicVolumeSize']
- if kms_key_id is None and 'kmsKeyId' in kwargs:
- kms_key_id = kwargs['kmsKeyId']
- if snapshot_id is None and 'snapshotId' in kwargs:
- snapshot_id = kwargs['snapshotId']
- if volume_size is None and 'volumeSize' in kwargs:
- volume_size = kwargs['volumeSize']
- if volume_type is None and 'volumeType' in kwargs:
- volume_type = kwargs['volumeType']
-
if delete_on_termination is not None:
- _setter("delete_on_termination", delete_on_termination)
+ pulumi.set(__self__, "delete_on_termination", delete_on_termination)
if dynamic_iops is not None:
- _setter("dynamic_iops", dynamic_iops)
+ pulumi.set(__self__, "dynamic_iops", dynamic_iops)
if dynamic_volume_size is not None:
- _setter("dynamic_volume_size", dynamic_volume_size)
+ pulumi.set(__self__, "dynamic_volume_size", dynamic_volume_size)
if encrypted is not None:
- _setter("encrypted", encrypted)
+ pulumi.set(__self__, "encrypted", encrypted)
if iops is not None:
- _setter("iops", iops)
+ pulumi.set(__self__, "iops", iops)
if kms_key_id is not None:
- _setter("kms_key_id", kms_key_id)
+ pulumi.set(__self__, "kms_key_id", kms_key_id)
if snapshot_id is not None:
- _setter("snapshot_id", snapshot_id)
+ pulumi.set(__self__, "snapshot_id", snapshot_id)
if throughput is not None:
- _setter("throughput", throughput)
+ pulumi.set(__self__, "throughput", throughput)
if volume_size is not None:
- _setter("volume_size", volume_size)
+ pulumi.set(__self__, "volume_size", volume_size)
if volume_type is not None:
- _setter("volume_type", volume_type)
+ pulumi.set(__self__, "volume_type", volume_type)
@property
@pulumi.getter(name="deleteOnTermination")
@@ -11962,34 +8930,9 @@ def __init__(__self__, *,
:param int base_size: Initial size for IOPS.
:param int size_per_resource_unit: Additional size per resource unit (in IOPS). (Example: `baseSize=50`, `sizePerResourceUnit=20`, and an instance with 2 CPU is launched; its IOPS size will be: 90).
"""
- OceanBlockDeviceMappingEbsDynamicIops._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- base_size=base_size,
- resource=resource,
- size_per_resource_unit=size_per_resource_unit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- base_size: Optional[int] = None,
- resource: Optional[str] = None,
- size_per_resource_unit: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if base_size is None and 'baseSize' in kwargs:
- base_size = kwargs['baseSize']
- if base_size is None:
- raise TypeError("Missing 'base_size' argument")
- if resource is None:
- raise TypeError("Missing 'resource' argument")
- if size_per_resource_unit is None and 'sizePerResourceUnit' in kwargs:
- size_per_resource_unit = kwargs['sizePerResourceUnit']
- if size_per_resource_unit is None:
- raise TypeError("Missing 'size_per_resource_unit' argument")
-
- _setter("base_size", base_size)
- _setter("resource", resource)
- _setter("size_per_resource_unit", size_per_resource_unit)
+ pulumi.set(__self__, "base_size", base_size)
+ pulumi.set(__self__, "resource", resource)
+ pulumi.set(__self__, "size_per_resource_unit", size_per_resource_unit)
@property
@pulumi.getter(name="baseSize")
@@ -12042,34 +8985,9 @@ def __init__(__self__, *,
:param int base_size: Initial size for IOPS.
:param int size_per_resource_unit: Additional size per resource unit (in IOPS). (Example: `baseSize=50`, `sizePerResourceUnit=20`, and an instance with 2 CPU is launched; its IOPS size will be: 90).
"""
- OceanBlockDeviceMappingEbsDynamicVolumeSize._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- base_size=base_size,
- resource=resource,
- size_per_resource_unit=size_per_resource_unit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- base_size: Optional[int] = None,
- resource: Optional[str] = None,
- size_per_resource_unit: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if base_size is None and 'baseSize' in kwargs:
- base_size = kwargs['baseSize']
- if base_size is None:
- raise TypeError("Missing 'base_size' argument")
- if resource is None:
- raise TypeError("Missing 'resource' argument")
- if size_per_resource_unit is None and 'sizePerResourceUnit' in kwargs:
- size_per_resource_unit = kwargs['sizePerResourceUnit']
- if size_per_resource_unit is None:
- raise TypeError("Missing 'size_per_resource_unit' argument")
-
- _setter("base_size", base_size)
- _setter("resource", resource)
- _setter("size_per_resource_unit", size_per_resource_unit)
+ pulumi.set(__self__, "base_size", base_size)
+ pulumi.set(__self__, "resource", resource)
+ pulumi.set(__self__, "size_per_resource_unit", size_per_resource_unit)
@property
@pulumi.getter(name="baseSize")
@@ -12117,21 +9035,8 @@ def __init__(__self__, *,
"""
:param str availability_vs_cost: You can control the approach that Ocean takes while launching nodes by configuring this value. Possible values: `costOriented`,`balanced`,`cheapest`.
"""
- OceanClusterOrientation._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- availability_vs_cost=availability_vs_cost,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- availability_vs_cost: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if availability_vs_cost is None and 'availabilityVsCost' in kwargs:
- availability_vs_cost = kwargs['availabilityVsCost']
-
if availability_vs_cost is not None:
- _setter("availability_vs_cost", availability_vs_cost)
+ pulumi.set(__self__, "availability_vs_cost", availability_vs_cost)
@property
@pulumi.getter(name="availabilityVsCost")
@@ -12232,123 +9137,44 @@ def __init__(__self__, *,
:param Sequence[str] root_device_types: The filtered instance types will have a root device types from this list.
:param Sequence[str] virtualization_types: The filtered instance types will support at least one of the virtualization types from this list.
"""
- OceanFilters._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- architectures=architectures,
- categories=categories,
- disk_types=disk_types,
- exclude_families=exclude_families,
- exclude_metal=exclude_metal,
- hypervisors=hypervisors,
- include_families=include_families,
- is_ena_supported=is_ena_supported,
- max_gpu=max_gpu,
- max_memory_gib=max_memory_gib,
- max_network_performance=max_network_performance,
- max_vcpu=max_vcpu,
- min_enis=min_enis,
- min_gpu=min_gpu,
- min_memory_gib=min_memory_gib,
- min_network_performance=min_network_performance,
- min_vcpu=min_vcpu,
- root_device_types=root_device_types,
- virtualization_types=virtualization_types,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- architectures: Optional[Sequence[str]] = None,
- categories: Optional[Sequence[str]] = None,
- disk_types: Optional[Sequence[str]] = None,
- exclude_families: Optional[Sequence[str]] = None,
- exclude_metal: Optional[bool] = None,
- hypervisors: Optional[Sequence[str]] = None,
- include_families: Optional[Sequence[str]] = None,
- is_ena_supported: Optional[str] = None,
- max_gpu: Optional[int] = None,
- max_memory_gib: Optional[float] = None,
- max_network_performance: Optional[int] = None,
- max_vcpu: Optional[int] = None,
- min_enis: Optional[int] = None,
- min_gpu: Optional[int] = None,
- min_memory_gib: Optional[float] = None,
- min_network_performance: Optional[int] = None,
- min_vcpu: Optional[int] = None,
- root_device_types: Optional[Sequence[str]] = None,
- virtualization_types: Optional[Sequence[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if disk_types is None and 'diskTypes' in kwargs:
- disk_types = kwargs['diskTypes']
- if exclude_families is None and 'excludeFamilies' in kwargs:
- exclude_families = kwargs['excludeFamilies']
- if exclude_metal is None and 'excludeMetal' in kwargs:
- exclude_metal = kwargs['excludeMetal']
- if include_families is None and 'includeFamilies' in kwargs:
- include_families = kwargs['includeFamilies']
- if is_ena_supported is None and 'isEnaSupported' in kwargs:
- is_ena_supported = kwargs['isEnaSupported']
- if max_gpu is None and 'maxGpu' in kwargs:
- max_gpu = kwargs['maxGpu']
- if max_memory_gib is None and 'maxMemoryGib' in kwargs:
- max_memory_gib = kwargs['maxMemoryGib']
- if max_network_performance is None and 'maxNetworkPerformance' in kwargs:
- max_network_performance = kwargs['maxNetworkPerformance']
- if max_vcpu is None and 'maxVcpu' in kwargs:
- max_vcpu = kwargs['maxVcpu']
- if min_enis is None and 'minEnis' in kwargs:
- min_enis = kwargs['minEnis']
- if min_gpu is None and 'minGpu' in kwargs:
- min_gpu = kwargs['minGpu']
- if min_memory_gib is None and 'minMemoryGib' in kwargs:
- min_memory_gib = kwargs['minMemoryGib']
- if min_network_performance is None and 'minNetworkPerformance' in kwargs:
- min_network_performance = kwargs['minNetworkPerformance']
- if min_vcpu is None and 'minVcpu' in kwargs:
- min_vcpu = kwargs['minVcpu']
- if root_device_types is None and 'rootDeviceTypes' in kwargs:
- root_device_types = kwargs['rootDeviceTypes']
- if virtualization_types is None and 'virtualizationTypes' in kwargs:
- virtualization_types = kwargs['virtualizationTypes']
-
if architectures is not None:
- _setter("architectures", architectures)
+ pulumi.set(__self__, "architectures", architectures)
if categories is not None:
- _setter("categories", categories)
+ pulumi.set(__self__, "categories", categories)
if disk_types is not None:
- _setter("disk_types", disk_types)
+ pulumi.set(__self__, "disk_types", disk_types)
if exclude_families is not None:
- _setter("exclude_families", exclude_families)
+ pulumi.set(__self__, "exclude_families", exclude_families)
if exclude_metal is not None:
- _setter("exclude_metal", exclude_metal)
+ pulumi.set(__self__, "exclude_metal", exclude_metal)
if hypervisors is not None:
- _setter("hypervisors", hypervisors)
+ pulumi.set(__self__, "hypervisors", hypervisors)
if include_families is not None:
- _setter("include_families", include_families)
+ pulumi.set(__self__, "include_families", include_families)
if is_ena_supported is not None:
- _setter("is_ena_supported", is_ena_supported)
+ pulumi.set(__self__, "is_ena_supported", is_ena_supported)
if max_gpu is not None:
- _setter("max_gpu", max_gpu)
+ pulumi.set(__self__, "max_gpu", max_gpu)
if max_memory_gib is not None:
- _setter("max_memory_gib", max_memory_gib)
+ pulumi.set(__self__, "max_memory_gib", max_memory_gib)
if max_network_performance is not None:
- _setter("max_network_performance", max_network_performance)
+ pulumi.set(__self__, "max_network_performance", max_network_performance)
if max_vcpu is not None:
- _setter("max_vcpu", max_vcpu)
+ pulumi.set(__self__, "max_vcpu", max_vcpu)
if min_enis is not None:
- _setter("min_enis", min_enis)
+ pulumi.set(__self__, "min_enis", min_enis)
if min_gpu is not None:
- _setter("min_gpu", min_gpu)
+ pulumi.set(__self__, "min_gpu", min_gpu)
if min_memory_gib is not None:
- _setter("min_memory_gib", min_memory_gib)
+ pulumi.set(__self__, "min_memory_gib", min_memory_gib)
if min_network_performance is not None:
- _setter("min_network_performance", min_network_performance)
+ pulumi.set(__self__, "min_network_performance", min_network_performance)
if min_vcpu is not None:
- _setter("min_vcpu", min_vcpu)
+ pulumi.set(__self__, "min_vcpu", min_vcpu)
if root_device_types is not None:
- _setter("root_device_types", root_device_types)
+ pulumi.set(__self__, "root_device_types", root_device_types)
if virtualization_types is not None:
- _setter("virtualization_types", virtualization_types)
+ pulumi.set(__self__, "virtualization_types", virtualization_types)
@property
@pulumi.getter
@@ -12531,28 +9357,9 @@ def __init__(__self__, *,
:param str http_tokens: Determines if a signed token is required or not. Valid values: `optional` or `required`.
:param int http_put_response_hop_limit: An integer from 1 through 64. The desired HTTP PUT response hop limit for instance metadata requests. The larger the number, the further the instance metadata requests can travel.
"""
- OceanInstanceMetadataOptions._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- http_tokens=http_tokens,
- http_put_response_hop_limit=http_put_response_hop_limit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- http_tokens: Optional[str] = None,
- http_put_response_hop_limit: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if http_tokens is None and 'httpTokens' in kwargs:
- http_tokens = kwargs['httpTokens']
- if http_tokens is None:
- raise TypeError("Missing 'http_tokens' argument")
- if http_put_response_hop_limit is None and 'httpPutResponseHopLimit' in kwargs:
- http_put_response_hop_limit = kwargs['httpPutResponseHopLimit']
-
- _setter("http_tokens", http_tokens)
+ pulumi.set(__self__, "http_tokens", http_tokens)
if http_put_response_hop_limit is not None:
- _setter("http_put_response_hop_limit", http_put_response_hop_limit)
+ pulumi.set(__self__, "http_put_response_hop_limit", http_put_response_hop_limit)
@property
@pulumi.getter(name="httpTokens")
@@ -12595,21 +9402,8 @@ def __init__(__self__, *,
"""
:param float max_scale_down_percentage: The maximum percentage allowed to scale down in a single scaling action on the nodes running in a specific VNG. Allowed only if maxScaleDownPercentage is set to null at the cluster level. Number between [0.1-100].
"""
- OceanLaunchSpecAutoscaleDown._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- max_scale_down_percentage=max_scale_down_percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- max_scale_down_percentage: Optional[float] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if max_scale_down_percentage is None and 'maxScaleDownPercentage' in kwargs:
- max_scale_down_percentage = kwargs['maxScaleDownPercentage']
-
if max_scale_down_percentage is not None:
- _setter("max_scale_down_percentage", max_scale_down_percentage)
+ pulumi.set(__self__, "max_scale_down_percentage", max_scale_down_percentage)
@property
@pulumi.getter(name="maxScaleDownPercentage")
@@ -12656,40 +9450,13 @@ def __init__(__self__, *,
:param int gpu_per_unit: Optionally configure the number of GPUS to allocate for each headroom unit.
:param int memory_per_unit: Optionally configure the amount of memory (MiB) to allocate for each headroom unit.
"""
- OceanLaunchSpecAutoscaleHeadroom._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- num_of_units=num_of_units,
- cpu_per_unit=cpu_per_unit,
- gpu_per_unit=gpu_per_unit,
- memory_per_unit=memory_per_unit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- num_of_units: Optional[int] = None,
- cpu_per_unit: Optional[int] = None,
- gpu_per_unit: Optional[int] = None,
- memory_per_unit: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if num_of_units is None and 'numOfUnits' in kwargs:
- num_of_units = kwargs['numOfUnits']
- if num_of_units is None:
- raise TypeError("Missing 'num_of_units' argument")
- if cpu_per_unit is None and 'cpuPerUnit' in kwargs:
- cpu_per_unit = kwargs['cpuPerUnit']
- if gpu_per_unit is None and 'gpuPerUnit' in kwargs:
- gpu_per_unit = kwargs['gpuPerUnit']
- if memory_per_unit is None and 'memoryPerUnit' in kwargs:
- memory_per_unit = kwargs['memoryPerUnit']
-
- _setter("num_of_units", num_of_units)
+ pulumi.set(__self__, "num_of_units", num_of_units)
if cpu_per_unit is not None:
- _setter("cpu_per_unit", cpu_per_unit)
+ pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
if gpu_per_unit is not None:
- _setter("gpu_per_unit", gpu_per_unit)
+ pulumi.set(__self__, "gpu_per_unit", gpu_per_unit)
if memory_per_unit is not None:
- _setter("memory_per_unit", memory_per_unit)
+ pulumi.set(__self__, "memory_per_unit", memory_per_unit)
@property
@pulumi.getter(name="numOfUnits")
@@ -12748,21 +9515,8 @@ def __init__(__self__, *,
"""
:param int auto_headroom_percentage: Number between 0-200 to control the headroom % of the specific Virtual Node Group. Effective when cluster.autoScaler.headroom.automatic.`is_enabled` = true is set on the Ocean cluster.
"""
- OceanLaunchSpecAutoscaleHeadroomsAutomatic._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- auto_headroom_percentage=auto_headroom_percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- auto_headroom_percentage: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if auto_headroom_percentage is None and 'autoHeadroomPercentage' in kwargs:
- auto_headroom_percentage = kwargs['autoHeadroomPercentage']
-
if auto_headroom_percentage is not None:
- _setter("auto_headroom_percentage", auto_headroom_percentage)
+ pulumi.set(__self__, "auto_headroom_percentage", auto_headroom_percentage)
@property
@pulumi.getter(name="autoHeadroomPercentage")
@@ -12806,37 +9560,14 @@ def __init__(__self__, *,
:param 'OceanLaunchSpecBlockDeviceMappingEbsArgs' ebs: Object. Set Elastic Block Store properties .
:param str no_device: String. Suppresses the specified device included in the block device mapping of the AMI.
"""
- OceanLaunchSpecBlockDeviceMapping._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- device_name=device_name,
- ebs=ebs,
- no_device=no_device,
- virtual_name=virtual_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- device_name: Optional[str] = None,
- ebs: Optional['outputs.OceanLaunchSpecBlockDeviceMappingEbs'] = None,
- no_device: Optional[str] = None,
- virtual_name: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if device_name is None and 'deviceName' in kwargs:
- device_name = kwargs['deviceName']
- if no_device is None and 'noDevice' in kwargs:
- no_device = kwargs['noDevice']
- if virtual_name is None and 'virtualName' in kwargs:
- virtual_name = kwargs['virtualName']
-
if device_name is not None:
- _setter("device_name", device_name)
+ pulumi.set(__self__, "device_name", device_name)
if ebs is not None:
- _setter("ebs", ebs)
+ pulumi.set(__self__, "ebs", ebs)
if no_device is not None:
- _setter("no_device", no_device)
+ pulumi.set(__self__, "no_device", no_device)
if virtual_name is not None:
- _setter("virtual_name", virtual_name)
+ pulumi.set(__self__, "virtual_name", virtual_name)
@property
@pulumi.getter(name="deviceName")
@@ -12918,63 +9649,24 @@ def __init__(__self__, *,
:param int volume_size: Int. The size, in GB of the volume.
:param str volume_type: String. The type of the volume. (Example: `gp2`).
"""
- OceanLaunchSpecBlockDeviceMappingEbs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- delete_on_termination=delete_on_termination,
- dynamic_volume_size=dynamic_volume_size,
- encrypted=encrypted,
- iops=iops,
- kms_key_id=kms_key_id,
- snapshot_id=snapshot_id,
- throughput=throughput,
- volume_size=volume_size,
- volume_type=volume_type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- delete_on_termination: Optional[bool] = None,
- dynamic_volume_size: Optional['outputs.OceanLaunchSpecBlockDeviceMappingEbsDynamicVolumeSize'] = None,
- encrypted: Optional[bool] = None,
- iops: Optional[int] = None,
- kms_key_id: Optional[str] = None,
- snapshot_id: Optional[str] = None,
- throughput: Optional[int] = None,
- volume_size: Optional[int] = None,
- volume_type: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if delete_on_termination is None and 'deleteOnTermination' in kwargs:
- delete_on_termination = kwargs['deleteOnTermination']
- if dynamic_volume_size is None and 'dynamicVolumeSize' in kwargs:
- dynamic_volume_size = kwargs['dynamicVolumeSize']
- if kms_key_id is None and 'kmsKeyId' in kwargs:
- kms_key_id = kwargs['kmsKeyId']
- if snapshot_id is None and 'snapshotId' in kwargs:
- snapshot_id = kwargs['snapshotId']
- if volume_size is None and 'volumeSize' in kwargs:
- volume_size = kwargs['volumeSize']
- if volume_type is None and 'volumeType' in kwargs:
- volume_type = kwargs['volumeType']
-
if delete_on_termination is not None:
- _setter("delete_on_termination", delete_on_termination)
+ pulumi.set(__self__, "delete_on_termination", delete_on_termination)
if dynamic_volume_size is not None:
- _setter("dynamic_volume_size", dynamic_volume_size)
+ pulumi.set(__self__, "dynamic_volume_size", dynamic_volume_size)
if encrypted is not None:
- _setter("encrypted", encrypted)
+ pulumi.set(__self__, "encrypted", encrypted)
if iops is not None:
- _setter("iops", iops)
+ pulumi.set(__self__, "iops", iops)
if kms_key_id is not None:
- _setter("kms_key_id", kms_key_id)
+ pulumi.set(__self__, "kms_key_id", kms_key_id)
if snapshot_id is not None:
- _setter("snapshot_id", snapshot_id)
+ pulumi.set(__self__, "snapshot_id", snapshot_id)
if throughput is not None:
- _setter("throughput", throughput)
+ pulumi.set(__self__, "throughput", throughput)
if volume_size is not None:
- _setter("volume_size", volume_size)
+ pulumi.set(__self__, "volume_size", volume_size)
if volume_type is not None:
- _setter("volume_type", volume_type)
+ pulumi.set(__self__, "volume_type", volume_type)
@property
@pulumi.getter(name="deleteOnTermination")
@@ -13079,34 +9771,9 @@ def __init__(__self__, *,
:param str resource: String. Resource type to increase volume size dynamically by. (Valid values: `CPU`)
:param int size_per_resource_unit: Int. Additional size (in GB) per resource unit. (Example: `baseSize=50`, `sizePerResourceUnit=20`, and instance with 2 CPU is launched; its total disk size will be: 90GB)
"""
- OceanLaunchSpecBlockDeviceMappingEbsDynamicVolumeSize._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- base_size=base_size,
- resource=resource,
- size_per_resource_unit=size_per_resource_unit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- base_size: Optional[int] = None,
- resource: Optional[str] = None,
- size_per_resource_unit: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if base_size is None and 'baseSize' in kwargs:
- base_size = kwargs['baseSize']
- if base_size is None:
- raise TypeError("Missing 'base_size' argument")
- if resource is None:
- raise TypeError("Missing 'resource' argument")
- if size_per_resource_unit is None and 'sizePerResourceUnit' in kwargs:
- size_per_resource_unit = kwargs['sizePerResourceUnit']
- if size_per_resource_unit is None:
- raise TypeError("Missing 'size_per_resource_unit' argument")
-
- _setter("base_size", base_size)
- _setter("resource", resource)
- _setter("size_per_resource_unit", size_per_resource_unit)
+ pulumi.set(__self__, "base_size", base_size)
+ pulumi.set(__self__, "resource", resource)
+ pulumi.set(__self__, "size_per_resource_unit", size_per_resource_unit)
@property
@pulumi.getter(name="baseSize")
@@ -13157,21 +9824,8 @@ def __init__(__self__, *,
"""
:param int initial_nodes: When set to an integer greater than 0, a corresponding amount of nodes will be launched from the created Virtual Node Group. The parameter is recommended in case the use_as_template_only (in aws.Ocean resource) is set to true during Ocean resource creation.
"""
- OceanLaunchSpecCreateOptions._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- initial_nodes=initial_nodes,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- initial_nodes: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if initial_nodes is None and 'initialNodes' in kwargs:
- initial_nodes = kwargs['initialNodes']
-
if initial_nodes is not None:
- _setter("initial_nodes", initial_nodes)
+ pulumi.set(__self__, "initial_nodes", initial_nodes)
@property
@pulumi.getter(name="initialNodes")
@@ -13210,28 +9864,9 @@ def __init__(__self__, *,
:param bool force_delete: When set to `true`, delete even if it is the last Virtual Node Group (also, the default Virtual Node Group must be configured with `useAsTemlateOnly = true`). Should be set at creation or update, but will be used only at deletion.
:param bool delete_nodes: When set to "true", all instances belonging to the deleted launch specification will be drained, detached, and terminated.
"""
- OceanLaunchSpecDeleteOptions._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- force_delete=force_delete,
- delete_nodes=delete_nodes,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- force_delete: Optional[bool] = None,
- delete_nodes: Optional[bool] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if force_delete is None and 'forceDelete' in kwargs:
- force_delete = kwargs['forceDelete']
- if force_delete is None:
- raise TypeError("Missing 'force_delete' argument")
- if delete_nodes is None and 'deleteNodes' in kwargs:
- delete_nodes = kwargs['deleteNodes']
-
- _setter("force_delete", force_delete)
+ pulumi.set(__self__, "force_delete", force_delete)
if delete_nodes is not None:
- _setter("delete_nodes", delete_nodes)
+ pulumi.set(__self__, "delete_nodes", delete_nodes)
@property
@pulumi.getter(name="forceDelete")
@@ -13274,21 +9909,8 @@ def __init__(__self__, *,
"""
:param 'OceanLaunchSpecElasticIpPoolTagSelectorArgs' tag_selector: A key-value pair, which defines an Elastic IP from the customer pool. Can be null.
"""
- OceanLaunchSpecElasticIpPool._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- tag_selector=tag_selector,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- tag_selector: Optional['outputs.OceanLaunchSpecElasticIpPoolTagSelector'] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if tag_selector is None and 'tagSelector' in kwargs:
- tag_selector = kwargs['tagSelector']
-
if tag_selector is not None:
- _setter("tag_selector", tag_selector)
+ pulumi.set(__self__, "tag_selector", tag_selector)
@property
@pulumi.getter(name="tagSelector")
@@ -13327,28 +9949,9 @@ def __init__(__self__, *,
:param str tag_key: Elastic IP tag key. The Virtual Node Group will consider all Elastic IPs tagged with this tag as a part of the Elastic IP pool to use.
:param str tag_value: Elastic IP tag value. Can be null.
"""
- OceanLaunchSpecElasticIpPoolTagSelector._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- tag_key=tag_key,
- tag_value=tag_value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- tag_key: Optional[str] = None,
- tag_value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if tag_key is None and 'tagKey' in kwargs:
- tag_key = kwargs['tagKey']
- if tag_key is None:
- raise TypeError("Missing 'tag_key' argument")
- if tag_value is None and 'tagValue' in kwargs:
- tag_value = kwargs['tagValue']
-
- _setter("tag_key", tag_key)
+ pulumi.set(__self__, "tag_key", tag_key)
if tag_value is not None:
- _setter("tag_value", tag_value)
+ pulumi.set(__self__, "tag_value", tag_value)
@property
@pulumi.getter(name="tagKey")
@@ -13391,21 +9994,8 @@ def __init__(__self__, *,
"""
:param str image_id: Identifier of the image in AWS. Valid values: any string which is not empty or null.
"""
- OceanLaunchSpecImage._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- image_id=image_id,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- image_id: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if image_id is None and 'imageId' in kwargs:
- image_id = kwargs['imageId']
-
if image_id is not None:
- _setter("image_id", image_id)
+ pulumi.set(__self__, "image_id", image_id)
@property
@pulumi.getter(name="imageId")
@@ -13444,28 +10034,9 @@ def __init__(__self__, *,
:param str http_tokens: Determines if a signed token is required or not. Valid values: `optional` or `required`.
:param int http_put_response_hop_limit: An integer from 1 through 64. The desired HTTP PUT response hop limit for instance metadata requests. The larger the number, the further the instance metadata requests can travel.
"""
- OceanLaunchSpecInstanceMetadataOptions._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- http_tokens=http_tokens,
- http_put_response_hop_limit=http_put_response_hop_limit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- http_tokens: Optional[str] = None,
- http_put_response_hop_limit: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if http_tokens is None and 'httpTokens' in kwargs:
- http_tokens = kwargs['httpTokens']
- if http_tokens is None:
- raise TypeError("Missing 'http_tokens' argument")
- if http_put_response_hop_limit is None and 'httpPutResponseHopLimit' in kwargs:
- http_put_response_hop_limit = kwargs['httpPutResponseHopLimit']
-
- _setter("http_tokens", http_tokens)
+ pulumi.set(__self__, "http_tokens", http_tokens)
if http_put_response_hop_limit is not None:
- _setter("http_put_response_hop_limit", http_put_response_hop_limit)
+ pulumi.set(__self__, "http_put_response_hop_limit", http_put_response_hop_limit)
@property
@pulumi.getter(name="httpTokens")
@@ -13575,119 +10146,42 @@ def __init__(__self__, *,
"""
- OceanLaunchSpecInstanceTypesFilters._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- categories=categories,
- disk_types=disk_types,
- exclude_families=exclude_families,
- exclude_metal=exclude_metal,
- hypervisors=hypervisors,
- include_families=include_families,
- is_ena_supported=is_ena_supported,
- max_gpu=max_gpu,
- max_memory_gib=max_memory_gib,
- max_network_performance=max_network_performance,
- max_vcpu=max_vcpu,
- min_enis=min_enis,
- min_gpu=min_gpu,
- min_memory_gib=min_memory_gib,
- min_network_performance=min_network_performance,
- min_vcpu=min_vcpu,
- root_device_types=root_device_types,
- virtualization_types=virtualization_types,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- categories: Optional[Sequence[str]] = None,
- disk_types: Optional[Sequence[str]] = None,
- exclude_families: Optional[Sequence[str]] = None,
- exclude_metal: Optional[bool] = None,
- hypervisors: Optional[Sequence[str]] = None,
- include_families: Optional[Sequence[str]] = None,
- is_ena_supported: Optional[str] = None,
- max_gpu: Optional[int] = None,
- max_memory_gib: Optional[float] = None,
- max_network_performance: Optional[int] = None,
- max_vcpu: Optional[int] = None,
- min_enis: Optional[int] = None,
- min_gpu: Optional[int] = None,
- min_memory_gib: Optional[float] = None,
- min_network_performance: Optional[int] = None,
- min_vcpu: Optional[int] = None,
- root_device_types: Optional[Sequence[str]] = None,
- virtualization_types: Optional[Sequence[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if disk_types is None and 'diskTypes' in kwargs:
- disk_types = kwargs['diskTypes']
- if exclude_families is None and 'excludeFamilies' in kwargs:
- exclude_families = kwargs['excludeFamilies']
- if exclude_metal is None and 'excludeMetal' in kwargs:
- exclude_metal = kwargs['excludeMetal']
- if include_families is None and 'includeFamilies' in kwargs:
- include_families = kwargs['includeFamilies']
- if is_ena_supported is None and 'isEnaSupported' in kwargs:
- is_ena_supported = kwargs['isEnaSupported']
- if max_gpu is None and 'maxGpu' in kwargs:
- max_gpu = kwargs['maxGpu']
- if max_memory_gib is None and 'maxMemoryGib' in kwargs:
- max_memory_gib = kwargs['maxMemoryGib']
- if max_network_performance is None and 'maxNetworkPerformance' in kwargs:
- max_network_performance = kwargs['maxNetworkPerformance']
- if max_vcpu is None and 'maxVcpu' in kwargs:
- max_vcpu = kwargs['maxVcpu']
- if min_enis is None and 'minEnis' in kwargs:
- min_enis = kwargs['minEnis']
- if min_gpu is None and 'minGpu' in kwargs:
- min_gpu = kwargs['minGpu']
- if min_memory_gib is None and 'minMemoryGib' in kwargs:
- min_memory_gib = kwargs['minMemoryGib']
- if min_network_performance is None and 'minNetworkPerformance' in kwargs:
- min_network_performance = kwargs['minNetworkPerformance']
- if min_vcpu is None and 'minVcpu' in kwargs:
- min_vcpu = kwargs['minVcpu']
- if root_device_types is None and 'rootDeviceTypes' in kwargs:
- root_device_types = kwargs['rootDeviceTypes']
- if virtualization_types is None and 'virtualizationTypes' in kwargs:
- virtualization_types = kwargs['virtualizationTypes']
-
if categories is not None:
- _setter("categories", categories)
+ pulumi.set(__self__, "categories", categories)
if disk_types is not None:
- _setter("disk_types", disk_types)
+ pulumi.set(__self__, "disk_types", disk_types)
if exclude_families is not None:
- _setter("exclude_families", exclude_families)
+ pulumi.set(__self__, "exclude_families", exclude_families)
if exclude_metal is not None:
- _setter("exclude_metal", exclude_metal)
+ pulumi.set(__self__, "exclude_metal", exclude_metal)
if hypervisors is not None:
- _setter("hypervisors", hypervisors)
+ pulumi.set(__self__, "hypervisors", hypervisors)
if include_families is not None:
- _setter("include_families", include_families)
+ pulumi.set(__self__, "include_families", include_families)
if is_ena_supported is not None:
- _setter("is_ena_supported", is_ena_supported)
+ pulumi.set(__self__, "is_ena_supported", is_ena_supported)
if max_gpu is not None:
- _setter("max_gpu", max_gpu)
+ pulumi.set(__self__, "max_gpu", max_gpu)
if max_memory_gib is not None:
- _setter("max_memory_gib", max_memory_gib)
+ pulumi.set(__self__, "max_memory_gib", max_memory_gib)
if max_network_performance is not None:
- _setter("max_network_performance", max_network_performance)
+ pulumi.set(__self__, "max_network_performance", max_network_performance)
if max_vcpu is not None:
- _setter("max_vcpu", max_vcpu)
+ pulumi.set(__self__, "max_vcpu", max_vcpu)
if min_enis is not None:
- _setter("min_enis", min_enis)
+ pulumi.set(__self__, "min_enis", min_enis)
if min_gpu is not None:
- _setter("min_gpu", min_gpu)
+ pulumi.set(__self__, "min_gpu", min_gpu)
if min_memory_gib is not None:
- _setter("min_memory_gib", min_memory_gib)
+ pulumi.set(__self__, "min_memory_gib", min_memory_gib)
if min_network_performance is not None:
- _setter("min_network_performance", min_network_performance)
+ pulumi.set(__self__, "min_network_performance", min_network_performance)
if min_vcpu is not None:
- _setter("min_vcpu", min_vcpu)
+ pulumi.set(__self__, "min_vcpu", min_vcpu)
if root_device_types is not None:
- _setter("root_device_types", root_device_types)
+ pulumi.set(__self__, "root_device_types", root_device_types)
if virtualization_types is not None:
- _setter("virtualization_types", virtualization_types)
+ pulumi.set(__self__, "virtualization_types", virtualization_types)
@property
@pulumi.getter
@@ -13846,25 +10340,8 @@ def __init__(__self__, *,
:param str key: The taint key.
:param str value: The taint value.
"""
- OceanLaunchSpecLabel._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -13911,27 +10388,10 @@ def __init__(__self__, *,
:param int max_instance_count: Set a maximum number of instances per Virtual Node Group. Can be null. If set, value must be greater than or equal to 0.
:param int min_instance_count: Set a minimum number of instances per Virtual Node Group. Can be null. If set, value must be greater than or equal to 0.
"""
- OceanLaunchSpecResourceLimit._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- max_instance_count=max_instance_count,
- min_instance_count=min_instance_count,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- max_instance_count: Optional[int] = None,
- min_instance_count: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if max_instance_count is None and 'maxInstanceCount' in kwargs:
- max_instance_count = kwargs['maxInstanceCount']
- if min_instance_count is None and 'minInstanceCount' in kwargs:
- min_instance_count = kwargs['minInstanceCount']
-
if max_instance_count is not None:
- _setter("max_instance_count", max_instance_count)
+ pulumi.set(__self__, "max_instance_count", max_instance_count)
if min_instance_count is not None:
- _setter("min_instance_count", min_instance_count)
+ pulumi.set(__self__, "min_instance_count", min_instance_count)
@property
@pulumi.getter(name="maxInstanceCount")
@@ -13978,28 +10438,9 @@ def __init__(__self__, *,
:param Sequence[str] time_windows: The times that the shutdown hours will apply.
:param bool is_enabled: Flag to enable or disable the shutdown hours mechanism. When False, the mechanism is deactivated, and the virtual node group remains in its current state.
"""
- OceanLaunchSpecSchedulingShutdownHours._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- time_windows=time_windows,
- is_enabled=is_enabled,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- time_windows: Optional[Sequence[str]] = None,
- is_enabled: Optional[bool] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if time_windows is None and 'timeWindows' in kwargs:
- time_windows = kwargs['timeWindows']
- if time_windows is None:
- raise TypeError("Missing 'time_windows' argument")
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
-
- _setter("time_windows", time_windows)
+ pulumi.set(__self__, "time_windows", time_windows)
if is_enabled is not None:
- _setter("is_enabled", is_enabled)
+ pulumi.set(__self__, "is_enabled", is_enabled)
@property
@pulumi.getter(name="timeWindows")
@@ -14054,42 +10495,11 @@ def __init__(__self__, *,
:param str task_type: The activity that you are scheduling. Valid values: "manualHeadroomUpdate".
:param Sequence['OceanLaunchSpecSchedulingTaskTaskHeadroomArgs'] task_headrooms: The config of this scheduled task. Depends on the value of taskType.
"""
- OceanLaunchSpecSchedulingTask._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cron_expression=cron_expression,
- is_enabled=is_enabled,
- task_type=task_type,
- task_headrooms=task_headrooms,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cron_expression: Optional[str] = None,
- is_enabled: Optional[bool] = None,
- task_type: Optional[str] = None,
- task_headrooms: Optional[Sequence['outputs.OceanLaunchSpecSchedulingTaskTaskHeadroom']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cron_expression is None and 'cronExpression' in kwargs:
- cron_expression = kwargs['cronExpression']
- if cron_expression is None:
- raise TypeError("Missing 'cron_expression' argument")
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
- if is_enabled is None:
- raise TypeError("Missing 'is_enabled' argument")
- if task_type is None and 'taskType' in kwargs:
- task_type = kwargs['taskType']
- if task_type is None:
- raise TypeError("Missing 'task_type' argument")
- if task_headrooms is None and 'taskHeadrooms' in kwargs:
- task_headrooms = kwargs['taskHeadrooms']
-
- _setter("cron_expression", cron_expression)
- _setter("is_enabled", is_enabled)
- _setter("task_type", task_type)
+ pulumi.set(__self__, "cron_expression", cron_expression)
+ pulumi.set(__self__, "is_enabled", is_enabled)
+ pulumi.set(__self__, "task_type", task_type)
if task_headrooms is not None:
- _setter("task_headrooms", task_headrooms)
+ pulumi.set(__self__, "task_headrooms", task_headrooms)
@property
@pulumi.getter(name="cronExpression")
@@ -14160,40 +10570,13 @@ def __init__(__self__, *,
:param int gpu_per_unit: Optionally configure the number of GPUS to allocate for each headroom unit.
:param int memory_per_unit: Optionally configure the amount of memory (MiB) to allocate for each headroom unit.
"""
- OceanLaunchSpecSchedulingTaskTaskHeadroom._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- num_of_units=num_of_units,
- cpu_per_unit=cpu_per_unit,
- gpu_per_unit=gpu_per_unit,
- memory_per_unit=memory_per_unit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- num_of_units: Optional[int] = None,
- cpu_per_unit: Optional[int] = None,
- gpu_per_unit: Optional[int] = None,
- memory_per_unit: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if num_of_units is None and 'numOfUnits' in kwargs:
- num_of_units = kwargs['numOfUnits']
- if num_of_units is None:
- raise TypeError("Missing 'num_of_units' argument")
- if cpu_per_unit is None and 'cpuPerUnit' in kwargs:
- cpu_per_unit = kwargs['cpuPerUnit']
- if gpu_per_unit is None and 'gpuPerUnit' in kwargs:
- gpu_per_unit = kwargs['gpuPerUnit']
- if memory_per_unit is None and 'memoryPerUnit' in kwargs:
- memory_per_unit = kwargs['memoryPerUnit']
-
- _setter("num_of_units", num_of_units)
+ pulumi.set(__self__, "num_of_units", num_of_units)
if cpu_per_unit is not None:
- _setter("cpu_per_unit", cpu_per_unit)
+ pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
if gpu_per_unit is not None:
- _setter("gpu_per_unit", gpu_per_unit)
+ pulumi.set(__self__, "gpu_per_unit", gpu_per_unit)
if memory_per_unit is not None:
- _setter("memory_per_unit", memory_per_unit)
+ pulumi.set(__self__, "memory_per_unit", memory_per_unit)
@property
@pulumi.getter(name="numOfUnits")
@@ -14252,21 +10635,8 @@ def __init__(__self__, *,
"""
:param int spot_percentage: The desired percentage of the Spot instances out of all running instances for this VNG. Only available when the field is not set in the cluster directly (cluster.strategy.spotPercentage).
"""
- OceanLaunchSpecStrategy._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- spot_percentage=spot_percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- spot_percentage: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if spot_percentage is None and 'spotPercentage' in kwargs:
- spot_percentage = kwargs['spotPercentage']
-
if spot_percentage is not None:
- _setter("spot_percentage", spot_percentage)
+ pulumi.set(__self__, "spot_percentage", spot_percentage)
@property
@pulumi.getter(name="spotPercentage")
@@ -14286,25 +10656,8 @@ def __init__(__self__, *,
:param str key: The taint key.
:param str value: The taint value.
"""
- OceanLaunchSpecTag._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -14334,30 +10687,9 @@ def __init__(__self__, *,
:param str key: The taint key.
:param str value: The taint value.
"""
- OceanLaunchSpecTaint._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- effect=effect,
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- effect: Optional[str] = None,
- key: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if effect is None:
- raise TypeError("Missing 'effect' argument")
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("effect", effect)
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "effect", effect)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -14408,28 +10740,9 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
should_roll: bool,
roll_config: Optional['outputs.OceanLaunchSpecUpdatePolicyRollConfig'] = None):
- OceanLaunchSpecUpdatePolicy._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- should_roll=should_roll,
- roll_config=roll_config,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- should_roll: Optional[bool] = None,
- roll_config: Optional['outputs.OceanLaunchSpecUpdatePolicyRollConfig'] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if should_roll is None and 'shouldRoll' in kwargs:
- should_roll = kwargs['shouldRoll']
- if should_roll is None:
- raise TypeError("Missing 'should_roll' argument")
- if roll_config is None and 'rollConfig' in kwargs:
- roll_config = kwargs['rollConfig']
-
- _setter("should_roll", should_roll)
+ pulumi.set(__self__, "should_roll", should_roll)
if roll_config is not None:
- _setter("roll_config", roll_config)
+ pulumi.set(__self__, "roll_config", roll_config)
@property
@pulumi.getter(name="shouldRoll")
@@ -14463,22 +10776,7 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
batch_size_percentage: int):
- OceanLaunchSpecUpdatePolicyRollConfig._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- batch_size_percentage=batch_size_percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- batch_size_percentage: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if batch_size_percentage is None and 'batchSizePercentage' in kwargs:
- batch_size_percentage = kwargs['batchSizePercentage']
- if batch_size_percentage is None:
- raise TypeError("Missing 'batch_size_percentage' argument")
-
- _setter("batch_size_percentage", batch_size_percentage)
+ pulumi.set(__self__, "batch_size_percentage", batch_size_percentage)
@property
@pulumi.getter(name="batchSizePercentage")
@@ -14497,27 +10795,12 @@ def __init__(__self__, *,
:param str name: Required if type is set to `CLASSIC`
:param str type: Can be set to `CLASSIC` or `TARGET_GROUP`
"""
- OceanLoadBalancer._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- arn=arn,
- name=name,
- type=type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- arn: Optional[str] = None,
- name: Optional[str] = None,
- type: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if arn is not None:
- _setter("arn", arn)
+ pulumi.set(__self__, "arn", arn)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if type is not None:
- _setter("type", type)
+ pulumi.set(__self__, "type", type)
@property
@pulumi.getter
@@ -14551,19 +10834,8 @@ def __init__(__self__, *,
"""
:param 'OceanLoggingExportArgs' export: Logging Export configuration.
"""
- OceanLogging._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- export=export,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- export: Optional['outputs.OceanLoggingExport'] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if export is not None:
- _setter("export", export)
+ pulumi.set(__self__, "export", export)
@property
@pulumi.getter
@@ -14581,19 +10853,8 @@ def __init__(__self__, *,
"""
:param Sequence['OceanLoggingExportS3Args'] s3s: Exports your cluster's logs to the S3 bucket and subdir configured on the S3 data integration given.
"""
- OceanLoggingExport._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- s3s=s3s,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- s3s: Optional[Sequence['outputs.OceanLoggingExportS3']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if s3s is not None:
- _setter("s3s", s3s)
+ pulumi.set(__self__, "s3s", s3s)
@property
@pulumi.getter
@@ -14611,20 +10872,7 @@ def __init__(__self__, *,
"""
:param str id: The identifier of The S3 data integration to export the logs to.
"""
- OceanLoggingExportS3._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- id=id,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- id: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if id is None:
- raise TypeError("Missing 'id' argument")
-
- _setter("id", id)
+ pulumi.set(__self__, "id", id)
@property
@pulumi.getter
@@ -14659,21 +10907,8 @@ def __init__(__self__, *,
"""
:param bool should_tag_volumes: Specify if Volume resources will be tagged with Virtual Node Group tags or Ocean tags.
"""
- OceanResourceTagSpecification._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- should_tag_volumes=should_tag_volumes,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- should_tag_volumes: Optional[bool] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if should_tag_volumes is None and 'shouldTagVolumes' in kwargs:
- should_tag_volumes = kwargs['shouldTagVolumes']
-
if should_tag_volumes is not None:
- _setter("should_tag_volumes", should_tag_volumes)
+ pulumi.set(__self__, "should_tag_volumes", should_tag_volumes)
@property
@pulumi.getter(name="shouldTagVolumes")
@@ -14706,25 +10941,10 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
shutdown_hours: Optional['outputs.OceanScheduledTaskShutdownHours'] = None,
tasks: Optional[Sequence['outputs.OceanScheduledTaskTask']] = None):
- OceanScheduledTask._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- shutdown_hours=shutdown_hours,
- tasks=tasks,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- shutdown_hours: Optional['outputs.OceanScheduledTaskShutdownHours'] = None,
- tasks: Optional[Sequence['outputs.OceanScheduledTaskTask']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if shutdown_hours is None and 'shutdownHours' in kwargs:
- shutdown_hours = kwargs['shutdownHours']
-
if shutdown_hours is not None:
- _setter("shutdown_hours", shutdown_hours)
+ pulumi.set(__self__, "shutdown_hours", shutdown_hours)
if tasks is not None:
- _setter("tasks", tasks)
+ pulumi.set(__self__, "tasks", tasks)
@property
@pulumi.getter(name="shutdownHours")
@@ -14761,28 +10981,9 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
time_windows: Sequence[str],
is_enabled: Optional[bool] = None):
- OceanScheduledTaskShutdownHours._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- time_windows=time_windows,
- is_enabled=is_enabled,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- time_windows: Optional[Sequence[str]] = None,
- is_enabled: Optional[bool] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if time_windows is None and 'timeWindows' in kwargs:
- time_windows = kwargs['timeWindows']
- if time_windows is None:
- raise TypeError("Missing 'time_windows' argument")
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
-
- _setter("time_windows", time_windows)
+ pulumi.set(__self__, "time_windows", time_windows)
if is_enabled is not None:
- _setter("is_enabled", is_enabled)
+ pulumi.set(__self__, "is_enabled", is_enabled)
@property
@pulumi.getter(name="timeWindows")
@@ -14822,36 +11023,9 @@ def __init__(__self__, *,
cron_expression: str,
is_enabled: bool,
task_type: str):
- OceanScheduledTaskTask._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cron_expression=cron_expression,
- is_enabled=is_enabled,
- task_type=task_type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cron_expression: Optional[str] = None,
- is_enabled: Optional[bool] = None,
- task_type: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cron_expression is None and 'cronExpression' in kwargs:
- cron_expression = kwargs['cronExpression']
- if cron_expression is None:
- raise TypeError("Missing 'cron_expression' argument")
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
- if is_enabled is None:
- raise TypeError("Missing 'is_enabled' argument")
- if task_type is None and 'taskType' in kwargs:
- task_type = kwargs['taskType']
- if task_type is None:
- raise TypeError("Missing 'task_type' argument")
-
- _setter("cron_expression", cron_expression)
- _setter("is_enabled", is_enabled)
- _setter("task_type", task_type)
+ pulumi.set(__self__, "cron_expression", cron_expression)
+ pulumi.set(__self__, "is_enabled", is_enabled)
+ pulumi.set(__self__, "task_type", task_type)
@property
@pulumi.getter(name="cronExpression")
@@ -14878,25 +11052,8 @@ def __init__(__self__, *,
:param str key: The tag key.
:param str value: The tag value.
"""
- OceanTag._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -14945,40 +11102,13 @@ def __init__(__self__, *,
auto_apply_tags: Optional[bool] = None,
conditioned_roll: Optional[bool] = None,
roll_config: Optional['outputs.OceanUpdatePolicyRollConfig'] = None):
- OceanUpdatePolicy._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- should_roll=should_roll,
- auto_apply_tags=auto_apply_tags,
- conditioned_roll=conditioned_roll,
- roll_config=roll_config,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- should_roll: Optional[bool] = None,
- auto_apply_tags: Optional[bool] = None,
- conditioned_roll: Optional[bool] = None,
- roll_config: Optional['outputs.OceanUpdatePolicyRollConfig'] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if should_roll is None and 'shouldRoll' in kwargs:
- should_roll = kwargs['shouldRoll']
- if should_roll is None:
- raise TypeError("Missing 'should_roll' argument")
- if auto_apply_tags is None and 'autoApplyTags' in kwargs:
- auto_apply_tags = kwargs['autoApplyTags']
- if conditioned_roll is None and 'conditionedRoll' in kwargs:
- conditioned_roll = kwargs['conditionedRoll']
- if roll_config is None and 'rollConfig' in kwargs:
- roll_config = kwargs['rollConfig']
-
- _setter("should_roll", should_roll)
+ pulumi.set(__self__, "should_roll", should_roll)
if auto_apply_tags is not None:
- _setter("auto_apply_tags", auto_apply_tags)
+ pulumi.set(__self__, "auto_apply_tags", auto_apply_tags)
if conditioned_roll is not None:
- _setter("conditioned_roll", conditioned_roll)
+ pulumi.set(__self__, "conditioned_roll", conditioned_roll)
if roll_config is not None:
- _setter("roll_config", roll_config)
+ pulumi.set(__self__, "roll_config", roll_config)
@property
@pulumi.getter(name="shouldRoll")
@@ -15031,40 +11161,13 @@ def __init__(__self__, *,
batch_min_healthy_percentage: Optional[int] = None,
launch_spec_ids: Optional[Sequence[str]] = None,
respect_pdb: Optional[bool] = None):
- OceanUpdatePolicyRollConfig._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- batch_size_percentage=batch_size_percentage,
- batch_min_healthy_percentage=batch_min_healthy_percentage,
- launch_spec_ids=launch_spec_ids,
- respect_pdb=respect_pdb,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- batch_size_percentage: Optional[int] = None,
- batch_min_healthy_percentage: Optional[int] = None,
- launch_spec_ids: Optional[Sequence[str]] = None,
- respect_pdb: Optional[bool] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if batch_size_percentage is None and 'batchSizePercentage' in kwargs:
- batch_size_percentage = kwargs['batchSizePercentage']
- if batch_size_percentage is None:
- raise TypeError("Missing 'batch_size_percentage' argument")
- if batch_min_healthy_percentage is None and 'batchMinHealthyPercentage' in kwargs:
- batch_min_healthy_percentage = kwargs['batchMinHealthyPercentage']
- if launch_spec_ids is None and 'launchSpecIds' in kwargs:
- launch_spec_ids = kwargs['launchSpecIds']
- if respect_pdb is None and 'respectPdb' in kwargs:
- respect_pdb = kwargs['respectPdb']
-
- _setter("batch_size_percentage", batch_size_percentage)
+ pulumi.set(__self__, "batch_size_percentage", batch_size_percentage)
if batch_min_healthy_percentage is not None:
- _setter("batch_min_healthy_percentage", batch_min_healthy_percentage)
+ pulumi.set(__self__, "batch_min_healthy_percentage", batch_min_healthy_percentage)
if launch_spec_ids is not None:
- _setter("launch_spec_ids", launch_spec_ids)
+ pulumi.set(__self__, "launch_spec_ids", launch_spec_ids)
if respect_pdb is not None:
- _setter("respect_pdb", respect_pdb)
+ pulumi.set(__self__, "respect_pdb", respect_pdb)
@property
@pulumi.getter(name="batchSizePercentage")
@@ -15094,20 +11197,7 @@ def __init__(__self__, *,
"""
:param str name: The name of process to suspend. Valid values: `"AUTO_HEALING" , "OUT_OF_STRATEGY", "PREVENTIVE_REPLACEMENT", "REVERT_PREFERRED", or "SCHEDULING"`.
"""
- SuspensionSuspension._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
-
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
@property
@pulumi.getter
diff --git a/sdk/python/pulumi_spotinst/aws/suspension.py b/sdk/python/pulumi_spotinst/aws/suspension.py
index 7e0fcf92..19a19b15 100644
--- a/sdk/python/pulumi_spotinst/aws/suspension.py
+++ b/sdk/python/pulumi_spotinst/aws/suspension.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs
from ._inputs import *
@@ -23,27 +23,8 @@ def __init__(__self__, *,
:param pulumi.Input[str] group_id: Elastigroup ID to apply the suspensions on.
:param pulumi.Input[Sequence[pulumi.Input['SuspensionSuspensionArgs']]] suspensions: block of single process to suspend.
"""
- SuspensionArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- group_id=group_id,
- suspensions=suspensions,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- group_id: Optional[pulumi.Input[str]] = None,
- suspensions: Optional[pulumi.Input[Sequence[pulumi.Input['SuspensionSuspensionArgs']]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if group_id is None and 'groupId' in kwargs:
- group_id = kwargs['groupId']
- if group_id is None:
- raise TypeError("Missing 'group_id' argument")
- if suspensions is None:
- raise TypeError("Missing 'suspensions' argument")
-
- _setter("group_id", group_id)
- _setter("suspensions", suspensions)
+ pulumi.set(__self__, "group_id", group_id)
+ pulumi.set(__self__, "suspensions", suspensions)
@property
@pulumi.getter(name="groupId")
@@ -80,25 +61,10 @@ def __init__(__self__, *,
:param pulumi.Input[str] group_id: Elastigroup ID to apply the suspensions on.
:param pulumi.Input[Sequence[pulumi.Input['SuspensionSuspensionArgs']]] suspensions: block of single process to suspend.
"""
- _SuspensionState._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- group_id=group_id,
- suspensions=suspensions,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- group_id: Optional[pulumi.Input[str]] = None,
- suspensions: Optional[pulumi.Input[Sequence[pulumi.Input['SuspensionSuspensionArgs']]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if group_id is None and 'groupId' in kwargs:
- group_id = kwargs['groupId']
-
if group_id is not None:
- _setter("group_id", group_id)
+ pulumi.set(__self__, "group_id", group_id)
if suspensions is not None:
- _setter("suspensions", suspensions)
+ pulumi.set(__self__, "suspensions", suspensions)
@property
@pulumi.getter(name="groupId")
@@ -200,10 +166,6 @@ def __init__(__self__, resource_name: str, *args, **kwargs):
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
- kwargs = kwargs or {}
- def _setter(key, value):
- kwargs[key] = value
- SuspensionArgs._configure(_setter, **kwargs)
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
diff --git a/sdk/python/pulumi_spotinst/azure/_inputs.py b/sdk/python/pulumi_spotinst/azure/_inputs.py
index 755ae188..884963a6 100644
--- a/sdk/python/pulumi_spotinst/azure/_inputs.py
+++ b/sdk/python/pulumi_spotinst/azure/_inputs.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
__all__ = [
@@ -78,34 +78,11 @@ def __init__(__self__, *,
health_check_type: pulumi.Input[str],
auto_healing: Optional[pulumi.Input[bool]] = None,
grace_period: Optional[pulumi.Input[int]] = None):
- ElastigroupHealthCheckArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- health_check_type=health_check_type,
- auto_healing=auto_healing,
- grace_period=grace_period,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- health_check_type: Optional[pulumi.Input[str]] = None,
- auto_healing: Optional[pulumi.Input[bool]] = None,
- grace_period: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if health_check_type is None and 'healthCheckType' in kwargs:
- health_check_type = kwargs['healthCheckType']
- if health_check_type is None:
- raise TypeError("Missing 'health_check_type' argument")
- if auto_healing is None and 'autoHealing' in kwargs:
- auto_healing = kwargs['autoHealing']
- if grace_period is None and 'gracePeriod' in kwargs:
- grace_period = kwargs['gracePeriod']
-
- _setter("health_check_type", health_check_type)
+ pulumi.set(__self__, "health_check_type", health_check_type)
if auto_healing is not None:
- _setter("auto_healing", auto_healing)
+ pulumi.set(__self__, "auto_healing", auto_healing)
if grace_period is not None:
- _setter("grace_period", grace_period)
+ pulumi.set(__self__, "grace_period", grace_period)
@property
@pulumi.getter(name="healthCheckType")
@@ -140,23 +117,10 @@ class ElastigroupImageArgs:
def __init__(__self__, *,
customs: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupImageCustomArgs']]]] = None,
marketplaces: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupImageMarketplaceArgs']]]] = None):
- ElastigroupImageArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- customs=customs,
- marketplaces=marketplaces,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- customs: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupImageCustomArgs']]]] = None,
- marketplaces: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupImageMarketplaceArgs']]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if customs is not None:
- _setter("customs", customs)
+ pulumi.set(__self__, "customs", customs)
if marketplaces is not None:
- _setter("marketplaces", marketplaces)
+ pulumi.set(__self__, "marketplaces", marketplaces)
@property
@pulumi.getter
@@ -185,29 +149,8 @@ def __init__(__self__, *,
"""
:param pulumi.Input[str] resource_group_name: Name of the Azure Resource Group where the Managed Service Identity is located.
"""
- ElastigroupImageCustomArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- image_name=image_name,
- resource_group_name=resource_group_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- image_name: Optional[pulumi.Input[str]] = None,
- resource_group_name: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if image_name is None and 'imageName' in kwargs:
- image_name = kwargs['imageName']
- if image_name is None:
- raise TypeError("Missing 'image_name' argument")
- if resource_group_name is None and 'resourceGroupName' in kwargs:
- resource_group_name = kwargs['resourceGroupName']
- if resource_group_name is None:
- raise TypeError("Missing 'resource_group_name' argument")
-
- _setter("image_name", image_name)
- _setter("resource_group_name", resource_group_name)
+ pulumi.set(__self__, "image_name", image_name)
+ pulumi.set(__self__, "resource_group_name", resource_group_name)
@property
@pulumi.getter(name="imageName")
@@ -237,30 +180,9 @@ def __init__(__self__, *,
offer: pulumi.Input[str],
publisher: pulumi.Input[str],
sku: pulumi.Input[str]):
- ElastigroupImageMarketplaceArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- offer=offer,
- publisher=publisher,
- sku=sku,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- offer: Optional[pulumi.Input[str]] = None,
- publisher: Optional[pulumi.Input[str]] = None,
- sku: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if offer is None:
- raise TypeError("Missing 'offer' argument")
- if publisher is None:
- raise TypeError("Missing 'publisher' argument")
- if sku is None:
- raise TypeError("Missing 'sku' argument")
-
- _setter("offer", offer)
- _setter("publisher", publisher)
- _setter("sku", sku)
+ pulumi.set(__self__, "offer", offer)
+ pulumi.set(__self__, "publisher", publisher)
+ pulumi.set(__self__, "sku", sku)
@property
@pulumi.getter
@@ -294,22 +216,7 @@ def sku(self, value: pulumi.Input[str]):
class ElastigroupIntegrationKubernetesArgs:
def __init__(__self__, *,
cluster_identifier: pulumi.Input[str]):
- ElastigroupIntegrationKubernetesArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cluster_identifier=cluster_identifier,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cluster_identifier: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cluster_identifier is None and 'clusterIdentifier' in kwargs:
- cluster_identifier = kwargs['clusterIdentifier']
- if cluster_identifier is None:
- raise TypeError("Missing 'cluster_identifier' argument")
-
- _setter("cluster_identifier", cluster_identifier)
+ pulumi.set(__self__, "cluster_identifier", cluster_identifier)
@property
@pulumi.getter(name="clusterIdentifier")
@@ -325,22 +232,7 @@ def cluster_identifier(self, value: pulumi.Input[str]):
class ElastigroupIntegrationMultaiRuntimeArgs:
def __init__(__self__, *,
deployment_id: pulumi.Input[str]):
- ElastigroupIntegrationMultaiRuntimeArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- deployment_id=deployment_id,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- deployment_id: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if deployment_id is None and 'deploymentId' in kwargs:
- deployment_id = kwargs['deploymentId']
- if deployment_id is None:
- raise TypeError("Missing 'deployment_id' argument")
-
- _setter("deployment_id", deployment_id)
+ pulumi.set(__self__, "deployment_id", deployment_id)
@property
@pulumi.getter(name="deploymentId")
@@ -359,38 +251,13 @@ def __init__(__self__, *,
auto_weight: Optional[pulumi.Input[bool]] = None,
balancer_id: Optional[pulumi.Input[str]] = None,
target_set_id: Optional[pulumi.Input[str]] = None):
- ElastigroupLoadBalancerArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- type=type,
- auto_weight=auto_weight,
- balancer_id=balancer_id,
- target_set_id=target_set_id,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- type: Optional[pulumi.Input[str]] = None,
- auto_weight: Optional[pulumi.Input[bool]] = None,
- balancer_id: Optional[pulumi.Input[str]] = None,
- target_set_id: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if type is None:
- raise TypeError("Missing 'type' argument")
- if auto_weight is None and 'autoWeight' in kwargs:
- auto_weight = kwargs['autoWeight']
- if balancer_id is None and 'balancerId' in kwargs:
- balancer_id = kwargs['balancerId']
- if target_set_id is None and 'targetSetId' in kwargs:
- target_set_id = kwargs['targetSetId']
-
- _setter("type", type)
+ pulumi.set(__self__, "type", type)
if auto_weight is not None:
- _setter("auto_weight", auto_weight)
+ pulumi.set(__self__, "auto_weight", auto_weight)
if balancer_id is not None:
- _setter("balancer_id", balancer_id)
+ pulumi.set(__self__, "balancer_id", balancer_id)
if target_set_id is not None:
- _setter("target_set_id", target_set_id)
+ pulumi.set(__self__, "target_set_id", target_set_id)
@property
@pulumi.getter
@@ -435,32 +302,11 @@ def __init__(__self__, *,
user_name: pulumi.Input[str],
password: Optional[pulumi.Input[str]] = None,
ssh_public_key: Optional[pulumi.Input[str]] = None):
- ElastigroupLoginArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- user_name=user_name,
- password=password,
- ssh_public_key=ssh_public_key,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- user_name: Optional[pulumi.Input[str]] = None,
- password: Optional[pulumi.Input[str]] = None,
- ssh_public_key: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if user_name is None and 'userName' in kwargs:
- user_name = kwargs['userName']
- if user_name is None:
- raise TypeError("Missing 'user_name' argument")
- if ssh_public_key is None and 'sshPublicKey' in kwargs:
- ssh_public_key = kwargs['sshPublicKey']
-
- _setter("user_name", user_name)
+ pulumi.set(__self__, "user_name", user_name)
if password is not None:
- _setter("password", password)
+ pulumi.set(__self__, "password", password)
if ssh_public_key is not None:
- _setter("ssh_public_key", ssh_public_key)
+ pulumi.set(__self__, "ssh_public_key", ssh_public_key)
@property
@pulumi.getter(name="userName")
@@ -499,27 +345,8 @@ def __init__(__self__, *,
:param pulumi.Input[str] name: Name of the Managed Service Identity.
:param pulumi.Input[str] resource_group_name: Name of the Azure Resource Group where the Managed Service Identity is located.
"""
- ElastigroupManagedServiceIdentityArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- resource_group_name=resource_group_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- resource_group_name: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
- if resource_group_name is None and 'resourceGroupName' in kwargs:
- resource_group_name = kwargs['resourceGroupName']
- if resource_group_name is None:
- raise TypeError("Missing 'resource_group_name' argument")
-
- _setter("name", name)
- _setter("resource_group_name", resource_group_name)
+ pulumi.set(__self__, "name", name)
+ pulumi.set(__self__, "resource_group_name", resource_group_name)
@property
@pulumi.getter
@@ -557,48 +384,13 @@ def __init__(__self__, *,
"""
:param pulumi.Input[str] resource_group_name: Name of the Azure Resource Group where the Managed Service Identity is located.
"""
- ElastigroupNetworkArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- resource_group_name=resource_group_name,
- subnet_name=subnet_name,
- virtual_network_name=virtual_network_name,
- additional_ip_configs=additional_ip_configs,
- assign_public_ip=assign_public_ip,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- resource_group_name: Optional[pulumi.Input[str]] = None,
- subnet_name: Optional[pulumi.Input[str]] = None,
- virtual_network_name: Optional[pulumi.Input[str]] = None,
- additional_ip_configs: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkAdditionalIpConfigArgs']]]] = None,
- assign_public_ip: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if resource_group_name is None and 'resourceGroupName' in kwargs:
- resource_group_name = kwargs['resourceGroupName']
- if resource_group_name is None:
- raise TypeError("Missing 'resource_group_name' argument")
- if subnet_name is None and 'subnetName' in kwargs:
- subnet_name = kwargs['subnetName']
- if subnet_name is None:
- raise TypeError("Missing 'subnet_name' argument")
- if virtual_network_name is None and 'virtualNetworkName' in kwargs:
- virtual_network_name = kwargs['virtualNetworkName']
- if virtual_network_name is None:
- raise TypeError("Missing 'virtual_network_name' argument")
- if additional_ip_configs is None and 'additionalIpConfigs' in kwargs:
- additional_ip_configs = kwargs['additionalIpConfigs']
- if assign_public_ip is None and 'assignPublicIp' in kwargs:
- assign_public_ip = kwargs['assignPublicIp']
-
- _setter("resource_group_name", resource_group_name)
- _setter("subnet_name", subnet_name)
- _setter("virtual_network_name", virtual_network_name)
+ pulumi.set(__self__, "resource_group_name", resource_group_name)
+ pulumi.set(__self__, "subnet_name", subnet_name)
+ pulumi.set(__self__, "virtual_network_name", virtual_network_name)
if additional_ip_configs is not None:
- _setter("additional_ip_configs", additional_ip_configs)
+ pulumi.set(__self__, "additional_ip_configs", additional_ip_configs)
if assign_public_ip is not None:
- _setter("assign_public_ip", assign_public_ip)
+ pulumi.set(__self__, "assign_public_ip", assign_public_ip)
@property
@pulumi.getter(name="resourceGroupName")
@@ -657,26 +449,9 @@ def __init__(__self__, *,
"""
:param pulumi.Input[str] name: Name of the Managed Service Identity.
"""
- ElastigroupNetworkAdditionalIpConfigArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- private_ip_version=private_ip_version,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- private_ip_version: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
- if private_ip_version is None and 'privateIpVersion' in kwargs:
- private_ip_version = kwargs['privateIpVersion']
-
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if private_ip_version is not None:
- _setter("private_ip_version", private_ip_version)
+ pulumi.set(__self__, "private_ip_version", private_ip_version)
@property
@pulumi.getter
@@ -721,103 +496,38 @@ def __init__(__self__, *,
statistic: Optional[pulumi.Input[str]] = None,
target: Optional[pulumi.Input[str]] = None,
unit: Optional[pulumi.Input[str]] = None):
- ElastigroupScalingDownPolicyArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- metric_name=metric_name,
- namespace=namespace,
- policy_name=policy_name,
- threshold=threshold,
- action_type=action_type,
- adjustment=adjustment,
- cooldown=cooldown,
- dimensions=dimensions,
- evaluation_periods=evaluation_periods,
- max_target_capacity=max_target_capacity,
- maximum=maximum,
- min_target_capacity=min_target_capacity,
- minimum=minimum,
- operator=operator,
- period=period,
- statistic=statistic,
- target=target,
- unit=unit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- metric_name: Optional[pulumi.Input[str]] = None,
- namespace: Optional[pulumi.Input[str]] = None,
- policy_name: Optional[pulumi.Input[str]] = None,
- threshold: Optional[pulumi.Input[float]] = None,
- action_type: Optional[pulumi.Input[str]] = None,
- adjustment: Optional[pulumi.Input[str]] = None,
- cooldown: Optional[pulumi.Input[int]] = None,
- dimensions: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyDimensionArgs']]]] = None,
- evaluation_periods: Optional[pulumi.Input[int]] = None,
- max_target_capacity: Optional[pulumi.Input[str]] = None,
- maximum: Optional[pulumi.Input[str]] = None,
- min_target_capacity: Optional[pulumi.Input[str]] = None,
- minimum: Optional[pulumi.Input[str]] = None,
- operator: Optional[pulumi.Input[str]] = None,
- period: Optional[pulumi.Input[int]] = None,
- statistic: Optional[pulumi.Input[str]] = None,
- target: Optional[pulumi.Input[str]] = None,
- unit: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if metric_name is None and 'metricName' in kwargs:
- metric_name = kwargs['metricName']
- if metric_name is None:
- raise TypeError("Missing 'metric_name' argument")
- if namespace is None:
- raise TypeError("Missing 'namespace' argument")
- if policy_name is None and 'policyName' in kwargs:
- policy_name = kwargs['policyName']
- if policy_name is None:
- raise TypeError("Missing 'policy_name' argument")
- if threshold is None:
- raise TypeError("Missing 'threshold' argument")
- if action_type is None and 'actionType' in kwargs:
- action_type = kwargs['actionType']
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
- if max_target_capacity is None and 'maxTargetCapacity' in kwargs:
- max_target_capacity = kwargs['maxTargetCapacity']
- if min_target_capacity is None and 'minTargetCapacity' in kwargs:
- min_target_capacity = kwargs['minTargetCapacity']
-
- _setter("metric_name", metric_name)
- _setter("namespace", namespace)
- _setter("policy_name", policy_name)
- _setter("threshold", threshold)
+ pulumi.set(__self__, "metric_name", metric_name)
+ pulumi.set(__self__, "namespace", namespace)
+ pulumi.set(__self__, "policy_name", policy_name)
+ pulumi.set(__self__, "threshold", threshold)
if action_type is not None:
- _setter("action_type", action_type)
+ pulumi.set(__self__, "action_type", action_type)
if adjustment is not None:
- _setter("adjustment", adjustment)
+ pulumi.set(__self__, "adjustment", adjustment)
if cooldown is not None:
- _setter("cooldown", cooldown)
+ pulumi.set(__self__, "cooldown", cooldown)
if dimensions is not None:
- _setter("dimensions", dimensions)
+ pulumi.set(__self__, "dimensions", dimensions)
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
if max_target_capacity is not None:
- _setter("max_target_capacity", max_target_capacity)
+ pulumi.set(__self__, "max_target_capacity", max_target_capacity)
if maximum is not None:
- _setter("maximum", maximum)
+ pulumi.set(__self__, "maximum", maximum)
if min_target_capacity is not None:
- _setter("min_target_capacity", min_target_capacity)
+ pulumi.set(__self__, "min_target_capacity", min_target_capacity)
if minimum is not None:
- _setter("minimum", minimum)
+ pulumi.set(__self__, "minimum", minimum)
if operator is not None:
- _setter("operator", operator)
+ pulumi.set(__self__, "operator", operator)
if period is not None:
- _setter("period", period)
+ pulumi.set(__self__, "period", period)
if statistic is not None:
- _setter("statistic", statistic)
+ pulumi.set(__self__, "statistic", statistic)
if target is not None:
- _setter("target", target)
+ pulumi.set(__self__, "target", target)
if unit is not None:
- _setter("unit", unit)
+ pulumi.set(__self__, "unit", unit)
@property
@pulumi.getter(name="metricName")
@@ -991,24 +701,9 @@ def __init__(__self__, *,
:param pulumi.Input[str] name: Name of the Managed Service Identity.
:param pulumi.Input[str] value: Tag Value for Vms in Elastigroup.
"""
- ElastigroupScalingDownPolicyDimensionArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
-
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if value is not None:
- _setter("value", value)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -1056,103 +751,38 @@ def __init__(__self__, *,
statistic: Optional[pulumi.Input[str]] = None,
target: Optional[pulumi.Input[str]] = None,
unit: Optional[pulumi.Input[str]] = None):
- ElastigroupScalingUpPolicyArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- metric_name=metric_name,
- namespace=namespace,
- policy_name=policy_name,
- threshold=threshold,
- action_type=action_type,
- adjustment=adjustment,
- cooldown=cooldown,
- dimensions=dimensions,
- evaluation_periods=evaluation_periods,
- max_target_capacity=max_target_capacity,
- maximum=maximum,
- min_target_capacity=min_target_capacity,
- minimum=minimum,
- operator=operator,
- period=period,
- statistic=statistic,
- target=target,
- unit=unit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- metric_name: Optional[pulumi.Input[str]] = None,
- namespace: Optional[pulumi.Input[str]] = None,
- policy_name: Optional[pulumi.Input[str]] = None,
- threshold: Optional[pulumi.Input[float]] = None,
- action_type: Optional[pulumi.Input[str]] = None,
- adjustment: Optional[pulumi.Input[str]] = None,
- cooldown: Optional[pulumi.Input[int]] = None,
- dimensions: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyDimensionArgs']]]] = None,
- evaluation_periods: Optional[pulumi.Input[int]] = None,
- max_target_capacity: Optional[pulumi.Input[str]] = None,
- maximum: Optional[pulumi.Input[str]] = None,
- min_target_capacity: Optional[pulumi.Input[str]] = None,
- minimum: Optional[pulumi.Input[str]] = None,
- operator: Optional[pulumi.Input[str]] = None,
- period: Optional[pulumi.Input[int]] = None,
- statistic: Optional[pulumi.Input[str]] = None,
- target: Optional[pulumi.Input[str]] = None,
- unit: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if metric_name is None and 'metricName' in kwargs:
- metric_name = kwargs['metricName']
- if metric_name is None:
- raise TypeError("Missing 'metric_name' argument")
- if namespace is None:
- raise TypeError("Missing 'namespace' argument")
- if policy_name is None and 'policyName' in kwargs:
- policy_name = kwargs['policyName']
- if policy_name is None:
- raise TypeError("Missing 'policy_name' argument")
- if threshold is None:
- raise TypeError("Missing 'threshold' argument")
- if action_type is None and 'actionType' in kwargs:
- action_type = kwargs['actionType']
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
- if max_target_capacity is None and 'maxTargetCapacity' in kwargs:
- max_target_capacity = kwargs['maxTargetCapacity']
- if min_target_capacity is None and 'minTargetCapacity' in kwargs:
- min_target_capacity = kwargs['minTargetCapacity']
-
- _setter("metric_name", metric_name)
- _setter("namespace", namespace)
- _setter("policy_name", policy_name)
- _setter("threshold", threshold)
+ pulumi.set(__self__, "metric_name", metric_name)
+ pulumi.set(__self__, "namespace", namespace)
+ pulumi.set(__self__, "policy_name", policy_name)
+ pulumi.set(__self__, "threshold", threshold)
if action_type is not None:
- _setter("action_type", action_type)
+ pulumi.set(__self__, "action_type", action_type)
if adjustment is not None:
- _setter("adjustment", adjustment)
+ pulumi.set(__self__, "adjustment", adjustment)
if cooldown is not None:
- _setter("cooldown", cooldown)
+ pulumi.set(__self__, "cooldown", cooldown)
if dimensions is not None:
- _setter("dimensions", dimensions)
+ pulumi.set(__self__, "dimensions", dimensions)
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
if max_target_capacity is not None:
- _setter("max_target_capacity", max_target_capacity)
+ pulumi.set(__self__, "max_target_capacity", max_target_capacity)
if maximum is not None:
- _setter("maximum", maximum)
+ pulumi.set(__self__, "maximum", maximum)
if min_target_capacity is not None:
- _setter("min_target_capacity", min_target_capacity)
+ pulumi.set(__self__, "min_target_capacity", min_target_capacity)
if minimum is not None:
- _setter("minimum", minimum)
+ pulumi.set(__self__, "minimum", minimum)
if operator is not None:
- _setter("operator", operator)
+ pulumi.set(__self__, "operator", operator)
if period is not None:
- _setter("period", period)
+ pulumi.set(__self__, "period", period)
if statistic is not None:
- _setter("statistic", statistic)
+ pulumi.set(__self__, "statistic", statistic)
if target is not None:
- _setter("target", target)
+ pulumi.set(__self__, "target", target)
if unit is not None:
- _setter("unit", unit)
+ pulumi.set(__self__, "unit", unit)
@property
@pulumi.getter(name="metricName")
@@ -1326,24 +956,9 @@ def __init__(__self__, *,
:param pulumi.Input[str] name: Name of the Managed Service Identity.
:param pulumi.Input[str] value: Tag Value for Vms in Elastigroup.
"""
- ElastigroupScalingUpPolicyDimensionArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
-
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if value is not None:
- _setter("value", value)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -1383,75 +998,24 @@ def __init__(__self__, *,
scale_max_capacity: Optional[pulumi.Input[str]] = None,
scale_min_capacity: Optional[pulumi.Input[str]] = None,
scale_target_capacity: Optional[pulumi.Input[str]] = None):
- ElastigroupScheduledTaskArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cron_expression=cron_expression,
- task_type=task_type,
- adjustment=adjustment,
- adjustment_percentage=adjustment_percentage,
- batch_size_percentage=batch_size_percentage,
- grace_period=grace_period,
- is_enabled=is_enabled,
- scale_max_capacity=scale_max_capacity,
- scale_min_capacity=scale_min_capacity,
- scale_target_capacity=scale_target_capacity,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cron_expression: Optional[pulumi.Input[str]] = None,
- task_type: Optional[pulumi.Input[str]] = None,
- adjustment: Optional[pulumi.Input[str]] = None,
- adjustment_percentage: Optional[pulumi.Input[str]] = None,
- batch_size_percentage: Optional[pulumi.Input[str]] = None,
- grace_period: Optional[pulumi.Input[str]] = None,
- is_enabled: Optional[pulumi.Input[bool]] = None,
- scale_max_capacity: Optional[pulumi.Input[str]] = None,
- scale_min_capacity: Optional[pulumi.Input[str]] = None,
- scale_target_capacity: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cron_expression is None and 'cronExpression' in kwargs:
- cron_expression = kwargs['cronExpression']
- if cron_expression is None:
- raise TypeError("Missing 'cron_expression' argument")
- if task_type is None and 'taskType' in kwargs:
- task_type = kwargs['taskType']
- if task_type is None:
- raise TypeError("Missing 'task_type' argument")
- if adjustment_percentage is None and 'adjustmentPercentage' in kwargs:
- adjustment_percentage = kwargs['adjustmentPercentage']
- if batch_size_percentage is None and 'batchSizePercentage' in kwargs:
- batch_size_percentage = kwargs['batchSizePercentage']
- if grace_period is None and 'gracePeriod' in kwargs:
- grace_period = kwargs['gracePeriod']
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
- if scale_max_capacity is None and 'scaleMaxCapacity' in kwargs:
- scale_max_capacity = kwargs['scaleMaxCapacity']
- if scale_min_capacity is None and 'scaleMinCapacity' in kwargs:
- scale_min_capacity = kwargs['scaleMinCapacity']
- if scale_target_capacity is None and 'scaleTargetCapacity' in kwargs:
- scale_target_capacity = kwargs['scaleTargetCapacity']
-
- _setter("cron_expression", cron_expression)
- _setter("task_type", task_type)
+ pulumi.set(__self__, "cron_expression", cron_expression)
+ pulumi.set(__self__, "task_type", task_type)
if adjustment is not None:
- _setter("adjustment", adjustment)
+ pulumi.set(__self__, "adjustment", adjustment)
if adjustment_percentage is not None:
- _setter("adjustment_percentage", adjustment_percentage)
+ pulumi.set(__self__, "adjustment_percentage", adjustment_percentage)
if batch_size_percentage is not None:
- _setter("batch_size_percentage", batch_size_percentage)
+ pulumi.set(__self__, "batch_size_percentage", batch_size_percentage)
if grace_period is not None:
- _setter("grace_period", grace_period)
+ pulumi.set(__self__, "grace_period", grace_period)
if is_enabled is not None:
- _setter("is_enabled", is_enabled)
+ pulumi.set(__self__, "is_enabled", is_enabled)
if scale_max_capacity is not None:
- _setter("scale_max_capacity", scale_max_capacity)
+ pulumi.set(__self__, "scale_max_capacity", scale_max_capacity)
if scale_min_capacity is not None:
- _setter("scale_min_capacity", scale_min_capacity)
+ pulumi.set(__self__, "scale_min_capacity", scale_min_capacity)
if scale_target_capacity is not None:
- _setter("scale_target_capacity", scale_target_capacity)
+ pulumi.set(__self__, "scale_target_capacity", scale_target_capacity)
@property
@pulumi.getter(name="cronExpression")
@@ -1550,33 +1114,12 @@ def __init__(__self__, *,
draining_timeout: Optional[pulumi.Input[int]] = None,
low_priority_percentage: Optional[pulumi.Input[int]] = None,
od_count: Optional[pulumi.Input[int]] = None):
- ElastigroupStrategyArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- draining_timeout=draining_timeout,
- low_priority_percentage=low_priority_percentage,
- od_count=od_count,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- draining_timeout: Optional[pulumi.Input[int]] = None,
- low_priority_percentage: Optional[pulumi.Input[int]] = None,
- od_count: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if draining_timeout is None and 'drainingTimeout' in kwargs:
- draining_timeout = kwargs['drainingTimeout']
- if low_priority_percentage is None and 'lowPriorityPercentage' in kwargs:
- low_priority_percentage = kwargs['lowPriorityPercentage']
- if od_count is None and 'odCount' in kwargs:
- od_count = kwargs['odCount']
-
if draining_timeout is not None:
- _setter("draining_timeout", draining_timeout)
+ pulumi.set(__self__, "draining_timeout", draining_timeout)
if low_priority_percentage is not None:
- _setter("low_priority_percentage", low_priority_percentage)
+ pulumi.set(__self__, "low_priority_percentage", low_priority_percentage)
if od_count is not None:
- _setter("od_count", od_count)
+ pulumi.set(__self__, "od_count", od_count)
@property
@pulumi.getter(name="drainingTimeout")
@@ -1611,28 +1154,9 @@ class ElastigroupUpdatePolicyArgs:
def __init__(__self__, *,
should_roll: pulumi.Input[bool],
roll_config: Optional[pulumi.Input['ElastigroupUpdatePolicyRollConfigArgs']] = None):
- ElastigroupUpdatePolicyArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- should_roll=should_roll,
- roll_config=roll_config,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- should_roll: Optional[pulumi.Input[bool]] = None,
- roll_config: Optional[pulumi.Input['ElastigroupUpdatePolicyRollConfigArgs']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if should_roll is None and 'shouldRoll' in kwargs:
- should_roll = kwargs['shouldRoll']
- if should_roll is None:
- raise TypeError("Missing 'should_roll' argument")
- if roll_config is None and 'rollConfig' in kwargs:
- roll_config = kwargs['rollConfig']
-
- _setter("should_roll", should_roll)
+ pulumi.set(__self__, "should_roll", should_roll)
if roll_config is not None:
- _setter("roll_config", roll_config)
+ pulumi.set(__self__, "roll_config", roll_config)
@property
@pulumi.getter(name="shouldRoll")
@@ -1659,34 +1183,11 @@ def __init__(__self__, *,
batch_size_percentage: pulumi.Input[int],
grace_period: Optional[pulumi.Input[int]] = None,
health_check_type: Optional[pulumi.Input[str]] = None):
- ElastigroupUpdatePolicyRollConfigArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- batch_size_percentage=batch_size_percentage,
- grace_period=grace_period,
- health_check_type=health_check_type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- batch_size_percentage: Optional[pulumi.Input[int]] = None,
- grace_period: Optional[pulumi.Input[int]] = None,
- health_check_type: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if batch_size_percentage is None and 'batchSizePercentage' in kwargs:
- batch_size_percentage = kwargs['batchSizePercentage']
- if batch_size_percentage is None:
- raise TypeError("Missing 'batch_size_percentage' argument")
- if grace_period is None and 'gracePeriod' in kwargs:
- grace_period = kwargs['gracePeriod']
- if health_check_type is None and 'healthCheckType' in kwargs:
- health_check_type = kwargs['healthCheckType']
-
- _setter("batch_size_percentage", batch_size_percentage)
+ pulumi.set(__self__, "batch_size_percentage", batch_size_percentage)
if grace_period is not None:
- _setter("grace_period", grace_period)
+ pulumi.set(__self__, "grace_period", grace_period)
if health_check_type is not None:
- _setter("health_check_type", health_check_type)
+ pulumi.set(__self__, "health_check_type", health_check_type)
@property
@pulumi.getter(name="batchSizePercentage")
@@ -1729,39 +1230,14 @@ def __init__(__self__, *,
:param pulumi.Input[bool] autoscale_is_enabled: Enable the Ocean Kubernetes Autoscaler.
:param pulumi.Input['OceanAutoscalerResourceLimitsArgs'] resource_limits: Optionally set upper and lower bounds on the resource usage of the cluster.
"""
- OceanAutoscalerArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- autoscale_down=autoscale_down,
- autoscale_headroom=autoscale_headroom,
- autoscale_is_enabled=autoscale_is_enabled,
- resource_limits=resource_limits,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- autoscale_down: Optional[pulumi.Input['OceanAutoscalerAutoscaleDownArgs']] = None,
- autoscale_headroom: Optional[pulumi.Input['OceanAutoscalerAutoscaleHeadroomArgs']] = None,
- autoscale_is_enabled: Optional[pulumi.Input[bool]] = None,
- resource_limits: Optional[pulumi.Input['OceanAutoscalerResourceLimitsArgs']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if autoscale_down is None and 'autoscaleDown' in kwargs:
- autoscale_down = kwargs['autoscaleDown']
- if autoscale_headroom is None and 'autoscaleHeadroom' in kwargs:
- autoscale_headroom = kwargs['autoscaleHeadroom']
- if autoscale_is_enabled is None and 'autoscaleIsEnabled' in kwargs:
- autoscale_is_enabled = kwargs['autoscaleIsEnabled']
- if resource_limits is None and 'resourceLimits' in kwargs:
- resource_limits = kwargs['resourceLimits']
-
if autoscale_down is not None:
- _setter("autoscale_down", autoscale_down)
+ pulumi.set(__self__, "autoscale_down", autoscale_down)
if autoscale_headroom is not None:
- _setter("autoscale_headroom", autoscale_headroom)
+ pulumi.set(__self__, "autoscale_headroom", autoscale_headroom)
if autoscale_is_enabled is not None:
- _setter("autoscale_is_enabled", autoscale_is_enabled)
+ pulumi.set(__self__, "autoscale_is_enabled", autoscale_is_enabled)
if resource_limits is not None:
- _setter("resource_limits", resource_limits)
+ pulumi.set(__self__, "resource_limits", resource_limits)
@property
@pulumi.getter(name="autoscaleDown")
@@ -1819,21 +1295,8 @@ def __init__(__self__, *,
"""
:param pulumi.Input[float] max_scale_down_percentage: Would represent the maximum % to scale-down.
"""
- OceanAutoscalerAutoscaleDownArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- max_scale_down_percentage=max_scale_down_percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- max_scale_down_percentage: Optional[pulumi.Input[float]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if max_scale_down_percentage is None and 'maxScaleDownPercentage' in kwargs:
- max_scale_down_percentage = kwargs['maxScaleDownPercentage']
-
if max_scale_down_percentage is not None:
- _setter("max_scale_down_percentage", max_scale_down_percentage)
+ pulumi.set(__self__, "max_scale_down_percentage", max_scale_down_percentage)
@property
@pulumi.getter(name="maxScaleDownPercentage")
@@ -1855,19 +1318,8 @@ def __init__(__self__, *,
"""
:param pulumi.Input['OceanAutoscalerAutoscaleHeadroomAutomaticArgs'] automatic: Automatic headroom configuration.
"""
- OceanAutoscalerAutoscaleHeadroomArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- automatic=automatic,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- automatic: Optional[pulumi.Input['OceanAutoscalerAutoscaleHeadroomAutomaticArgs']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if automatic is not None:
- _setter("automatic", automatic)
+ pulumi.set(__self__, "automatic", automatic)
@property
@pulumi.getter
@@ -1891,25 +1343,10 @@ def __init__(__self__, *,
:param pulumi.Input[bool] is_enabled: Enable automatic headroom. When set to `true`, Ocean configures and optimizes headroom automatically.
:param pulumi.Input[int] percentage: Optionally set a number between 0-100 to control the percentage of total cluster resources dedicated to headroom. Relevant when `isEnabled` is toggled on.
"""
- OceanAutoscalerAutoscaleHeadroomAutomaticArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- is_enabled=is_enabled,
- percentage=percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- is_enabled: Optional[pulumi.Input[bool]] = None,
- percentage: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
-
if is_enabled is not None:
- _setter("is_enabled", is_enabled)
+ pulumi.set(__self__, "is_enabled", is_enabled)
if percentage is not None:
- _setter("percentage", percentage)
+ pulumi.set(__self__, "percentage", percentage)
@property
@pulumi.getter(name="isEnabled")
@@ -1945,27 +1382,10 @@ def __init__(__self__, *,
:param pulumi.Input[int] max_memory_gib: The maximum memory in GiB units that can be allocated to the cluster.
:param pulumi.Input[int] max_vcpu: The maximum cpu in vCpu units that can be allocated to the cluster.
"""
- OceanAutoscalerResourceLimitsArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- max_memory_gib=max_memory_gib,
- max_vcpu=max_vcpu,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- max_memory_gib: Optional[pulumi.Input[int]] = None,
- max_vcpu: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if max_memory_gib is None and 'maxMemoryGib' in kwargs:
- max_memory_gib = kwargs['maxMemoryGib']
- if max_vcpu is None and 'maxVcpu' in kwargs:
- max_vcpu = kwargs['maxVcpu']
-
if max_memory_gib is not None:
- _setter("max_memory_gib", max_memory_gib)
+ pulumi.set(__self__, "max_memory_gib", max_memory_gib)
if max_vcpu is not None:
- _setter("max_vcpu", max_vcpu)
+ pulumi.set(__self__, "max_vcpu", max_vcpu)
@property
@pulumi.getter(name="maxMemoryGib")
@@ -2007,39 +1427,16 @@ def __init__(__self__, *,
:param pulumi.Input[str] publisher: Image publisher.
:param pulumi.Input[str] type: The type of load balancer. Supported value: `loadBalancer`
"""
- OceanExtensionArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- api_version=api_version,
- minor_version_auto_upgrade=minor_version_auto_upgrade,
- name=name,
- publisher=publisher,
- type=type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- api_version: Optional[pulumi.Input[str]] = None,
- minor_version_auto_upgrade: Optional[pulumi.Input[bool]] = None,
- name: Optional[pulumi.Input[str]] = None,
- publisher: Optional[pulumi.Input[str]] = None,
- type: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if api_version is None and 'apiVersion' in kwargs:
- api_version = kwargs['apiVersion']
- if minor_version_auto_upgrade is None and 'minorVersionAutoUpgrade' in kwargs:
- minor_version_auto_upgrade = kwargs['minorVersionAutoUpgrade']
-
if api_version is not None:
- _setter("api_version", api_version)
+ pulumi.set(__self__, "api_version", api_version)
if minor_version_auto_upgrade is not None:
- _setter("minor_version_auto_upgrade", minor_version_auto_upgrade)
+ pulumi.set(__self__, "minor_version_auto_upgrade", minor_version_auto_upgrade)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if publisher is not None:
- _setter("publisher", publisher)
+ pulumi.set(__self__, "publisher", publisher)
if type is not None:
- _setter("type", type)
+ pulumi.set(__self__, "type", type)
@property
@pulumi.getter(name="apiVersion")
@@ -2109,21 +1506,8 @@ def __init__(__self__, *,
"""
:param pulumi.Input[int] grace_period: The amount of time to wait, in seconds, from the moment the instance has launched before monitoring its health checks.
"""
- OceanHealthArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- grace_period=grace_period,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- grace_period: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if grace_period is None and 'gracePeriod' in kwargs:
- grace_period = kwargs['gracePeriod']
-
if grace_period is not None:
- _setter("grace_period", grace_period)
+ pulumi.set(__self__, "grace_period", grace_period)
@property
@pulumi.getter(name="gracePeriod")
@@ -2145,19 +1529,8 @@ def __init__(__self__, *,
"""
:param pulumi.Input[Sequence[pulumi.Input['OceanImageMarketplaceArgs']]] marketplaces: Select an image from Azure's Marketplace image catalogue.
"""
- OceanImageArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- marketplaces=marketplaces,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- marketplaces: Optional[pulumi.Input[Sequence[pulumi.Input['OceanImageMarketplaceArgs']]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if marketplaces is not None:
- _setter("marketplaces", marketplaces)
+ pulumi.set(__self__, "marketplaces", marketplaces)
@property
@pulumi.getter
@@ -2185,31 +1558,14 @@ def __init__(__self__, *,
:param pulumi.Input[str] sku: Image Stock Keeping Unit (which is the specific version of the image).
:param pulumi.Input[str] version: Image version.
"""
- OceanImageMarketplaceArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- offer=offer,
- publisher=publisher,
- sku=sku,
- version=version,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- offer: Optional[pulumi.Input[str]] = None,
- publisher: Optional[pulumi.Input[str]] = None,
- sku: Optional[pulumi.Input[str]] = None,
- version: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if offer is not None:
- _setter("offer", offer)
+ pulumi.set(__self__, "offer", offer)
if publisher is not None:
- _setter("publisher", publisher)
+ pulumi.set(__self__, "publisher", publisher)
if sku is not None:
- _setter("sku", sku)
+ pulumi.set(__self__, "sku", sku)
if version is not None:
- _setter("version", version)
+ pulumi.set(__self__, "version", version)
@property
@pulumi.getter
@@ -2275,41 +1631,16 @@ def __init__(__self__, *,
:param pulumi.Input[str] resource_group_name: The Resource Group name of the Load Balancer.
:param pulumi.Input[str] type: The type of load balancer. Supported value: `loadBalancer`
"""
- OceanLoadBalancerArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- backend_pool_names=backend_pool_names,
- load_balancer_sku=load_balancer_sku,
- name=name,
- resource_group_name=resource_group_name,
- type=type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- backend_pool_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- load_balancer_sku: Optional[pulumi.Input[str]] = None,
- name: Optional[pulumi.Input[str]] = None,
- resource_group_name: Optional[pulumi.Input[str]] = None,
- type: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if backend_pool_names is None and 'backendPoolNames' in kwargs:
- backend_pool_names = kwargs['backendPoolNames']
- if load_balancer_sku is None and 'loadBalancerSku' in kwargs:
- load_balancer_sku = kwargs['loadBalancerSku']
- if resource_group_name is None and 'resourceGroupName' in kwargs:
- resource_group_name = kwargs['resourceGroupName']
-
if backend_pool_names is not None:
- _setter("backend_pool_names", backend_pool_names)
+ pulumi.set(__self__, "backend_pool_names", backend_pool_names)
if load_balancer_sku is not None:
- _setter("load_balancer_sku", load_balancer_sku)
+ pulumi.set(__self__, "load_balancer_sku", load_balancer_sku)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if resource_group_name is not None:
- _setter("resource_group_name", resource_group_name)
+ pulumi.set(__self__, "resource_group_name", resource_group_name)
if type is not None:
- _setter("type", type)
+ pulumi.set(__self__, "type", type)
@property
@pulumi.getter(name="backendPoolNames")
@@ -2381,27 +1712,8 @@ def __init__(__self__, *,
:param pulumi.Input[str] name: Name of the Load Balancer.
:param pulumi.Input[str] resource_group_name: The Resource Group name of the Load Balancer.
"""
- OceanManagedServiceIdentityArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- resource_group_name=resource_group_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- resource_group_name: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
- if resource_group_name is None and 'resourceGroupName' in kwargs:
- resource_group_name = kwargs['resourceGroupName']
- if resource_group_name is None:
- raise TypeError("Missing 'resource_group_name' argument")
-
- _setter("name", name)
- _setter("resource_group_name", resource_group_name)
+ pulumi.set(__self__, "name", name)
+ pulumi.set(__self__, "resource_group_name", resource_group_name)
@property
@pulumi.getter
@@ -2439,33 +1751,12 @@ def __init__(__self__, *,
:param pulumi.Input[str] resource_group_name: The Resource Group name of the Load Balancer.
:param pulumi.Input[str] virtual_network_name: Virtual network.
"""
- OceanNetworkArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- network_interfaces=network_interfaces,
- resource_group_name=resource_group_name,
- virtual_network_name=virtual_network_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- network_interfaces: Optional[pulumi.Input[Sequence[pulumi.Input['OceanNetworkNetworkInterfaceArgs']]]] = None,
- resource_group_name: Optional[pulumi.Input[str]] = None,
- virtual_network_name: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if network_interfaces is None and 'networkInterfaces' in kwargs:
- network_interfaces = kwargs['networkInterfaces']
- if resource_group_name is None and 'resourceGroupName' in kwargs:
- resource_group_name = kwargs['resourceGroupName']
- if virtual_network_name is None and 'virtualNetworkName' in kwargs:
- virtual_network_name = kwargs['virtualNetworkName']
-
if network_interfaces is not None:
- _setter("network_interfaces", network_interfaces)
+ pulumi.set(__self__, "network_interfaces", network_interfaces)
if resource_group_name is not None:
- _setter("resource_group_name", resource_group_name)
+ pulumi.set(__self__, "resource_group_name", resource_group_name)
if virtual_network_name is not None:
- _setter("virtual_network_name", virtual_network_name)
+ pulumi.set(__self__, "virtual_network_name", virtual_network_name)
@property
@pulumi.getter(name="networkInterfaces")
@@ -2518,45 +1809,16 @@ def __init__(__self__, *,
:param pulumi.Input[bool] is_primary: Defines whether the network interface is primary or not.
:param pulumi.Input[str] subnet_name: Subnet name.
"""
- OceanNetworkNetworkInterfaceArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- additional_ip_configs=additional_ip_configs,
- assign_public_ip=assign_public_ip,
- is_primary=is_primary,
- security_group=security_group,
- subnet_name=subnet_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- additional_ip_configs: Optional[pulumi.Input[Sequence[pulumi.Input['OceanNetworkNetworkInterfaceAdditionalIpConfigArgs']]]] = None,
- assign_public_ip: Optional[pulumi.Input[bool]] = None,
- is_primary: Optional[pulumi.Input[bool]] = None,
- security_group: Optional[pulumi.Input['OceanNetworkNetworkInterfaceSecurityGroupArgs']] = None,
- subnet_name: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if additional_ip_configs is None and 'additionalIpConfigs' in kwargs:
- additional_ip_configs = kwargs['additionalIpConfigs']
- if assign_public_ip is None and 'assignPublicIp' in kwargs:
- assign_public_ip = kwargs['assignPublicIp']
- if is_primary is None and 'isPrimary' in kwargs:
- is_primary = kwargs['isPrimary']
- if security_group is None and 'securityGroup' in kwargs:
- security_group = kwargs['securityGroup']
- if subnet_name is None and 'subnetName' in kwargs:
- subnet_name = kwargs['subnetName']
-
if additional_ip_configs is not None:
- _setter("additional_ip_configs", additional_ip_configs)
+ pulumi.set(__self__, "additional_ip_configs", additional_ip_configs)
if assign_public_ip is not None:
- _setter("assign_public_ip", assign_public_ip)
+ pulumi.set(__self__, "assign_public_ip", assign_public_ip)
if is_primary is not None:
- _setter("is_primary", is_primary)
+ pulumi.set(__self__, "is_primary", is_primary)
if security_group is not None:
- _setter("security_group", security_group)
+ pulumi.set(__self__, "security_group", security_group)
if subnet_name is not None:
- _setter("subnet_name", subnet_name)
+ pulumi.set(__self__, "subnet_name", subnet_name)
@property
@pulumi.getter(name="additionalIpConfigs")
@@ -2625,25 +1887,10 @@ def __init__(__self__, *,
:param pulumi.Input[str] name: Name of the Load Balancer.
:param pulumi.Input[str] private_ip_version: Supported values: `IPv4`, `IPv6`.
"""
- OceanNetworkNetworkInterfaceAdditionalIpConfigArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- private_ip_version=private_ip_version,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- private_ip_version: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if private_ip_version is None and 'privateIpVersion' in kwargs:
- private_ip_version = kwargs['privateIpVersion']
-
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if private_ip_version is not None:
- _setter("private_ip_version", private_ip_version)
+ pulumi.set(__self__, "private_ip_version", private_ip_version)
@property
@pulumi.getter
@@ -2679,25 +1926,10 @@ def __init__(__self__, *,
:param pulumi.Input[str] name: Name of the Load Balancer.
:param pulumi.Input[str] resource_group_name: The Resource Group name of the Load Balancer.
"""
- OceanNetworkNetworkInterfaceSecurityGroupArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- resource_group_name=resource_group_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- resource_group_name: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if resource_group_name is None and 'resourceGroupName' in kwargs:
- resource_group_name = kwargs['resourceGroupName']
-
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if resource_group_name is not None:
- _setter("resource_group_name", resource_group_name)
+ pulumi.set(__self__, "resource_group_name", resource_group_name)
@property
@pulumi.getter
@@ -2731,39 +1963,14 @@ def __init__(__self__, *,
autoscale_headroom: Optional[pulumi.Input['OceanNpAutoscalerAutoscaleHeadroomArgs']] = None,
autoscale_is_enabled: Optional[pulumi.Input[bool]] = None,
resource_limits: Optional[pulumi.Input['OceanNpAutoscalerResourceLimitsArgs']] = None):
- OceanNpAutoscalerArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- autoscale_down=autoscale_down,
- autoscale_headroom=autoscale_headroom,
- autoscale_is_enabled=autoscale_is_enabled,
- resource_limits=resource_limits,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- autoscale_down: Optional[pulumi.Input['OceanNpAutoscalerAutoscaleDownArgs']] = None,
- autoscale_headroom: Optional[pulumi.Input['OceanNpAutoscalerAutoscaleHeadroomArgs']] = None,
- autoscale_is_enabled: Optional[pulumi.Input[bool]] = None,
- resource_limits: Optional[pulumi.Input['OceanNpAutoscalerResourceLimitsArgs']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if autoscale_down is None and 'autoscaleDown' in kwargs:
- autoscale_down = kwargs['autoscaleDown']
- if autoscale_headroom is None and 'autoscaleHeadroom' in kwargs:
- autoscale_headroom = kwargs['autoscaleHeadroom']
- if autoscale_is_enabled is None and 'autoscaleIsEnabled' in kwargs:
- autoscale_is_enabled = kwargs['autoscaleIsEnabled']
- if resource_limits is None and 'resourceLimits' in kwargs:
- resource_limits = kwargs['resourceLimits']
-
if autoscale_down is not None:
- _setter("autoscale_down", autoscale_down)
+ pulumi.set(__self__, "autoscale_down", autoscale_down)
if autoscale_headroom is not None:
- _setter("autoscale_headroom", autoscale_headroom)
+ pulumi.set(__self__, "autoscale_headroom", autoscale_headroom)
if autoscale_is_enabled is not None:
- _setter("autoscale_is_enabled", autoscale_is_enabled)
+ pulumi.set(__self__, "autoscale_is_enabled", autoscale_is_enabled)
if resource_limits is not None:
- _setter("resource_limits", resource_limits)
+ pulumi.set(__self__, "resource_limits", resource_limits)
@property
@pulumi.getter(name="autoscaleDown")
@@ -2806,21 +2013,8 @@ def resource_limits(self, value: Optional[pulumi.Input['OceanNpAutoscalerResourc
class OceanNpAutoscalerAutoscaleDownArgs:
def __init__(__self__, *,
max_scale_down_percentage: Optional[pulumi.Input[int]] = None):
- OceanNpAutoscalerAutoscaleDownArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- max_scale_down_percentage=max_scale_down_percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- max_scale_down_percentage: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if max_scale_down_percentage is None and 'maxScaleDownPercentage' in kwargs:
- max_scale_down_percentage = kwargs['maxScaleDownPercentage']
-
if max_scale_down_percentage is not None:
- _setter("max_scale_down_percentage", max_scale_down_percentage)
+ pulumi.set(__self__, "max_scale_down_percentage", max_scale_down_percentage)
@property
@pulumi.getter(name="maxScaleDownPercentage")
@@ -2836,19 +2030,8 @@ def max_scale_down_percentage(self, value: Optional[pulumi.Input[int]]):
class OceanNpAutoscalerAutoscaleHeadroomArgs:
def __init__(__self__, *,
automatic: Optional[pulumi.Input['OceanNpAutoscalerAutoscaleHeadroomAutomaticArgs']] = None):
- OceanNpAutoscalerAutoscaleHeadroomArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- automatic=automatic,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- automatic: Optional[pulumi.Input['OceanNpAutoscalerAutoscaleHeadroomAutomaticArgs']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if automatic is not None:
- _setter("automatic", automatic)
+ pulumi.set(__self__, "automatic", automatic)
@property
@pulumi.getter
@@ -2864,19 +2047,8 @@ def automatic(self, value: Optional[pulumi.Input['OceanNpAutoscalerAutoscaleHead
class OceanNpAutoscalerAutoscaleHeadroomAutomaticArgs:
def __init__(__self__, *,
percentage: Optional[pulumi.Input[int]] = None):
- OceanNpAutoscalerAutoscaleHeadroomAutomaticArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- percentage=percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- percentage: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if percentage is not None:
- _setter("percentage", percentage)
+ pulumi.set(__self__, "percentage", percentage)
@property
@pulumi.getter
@@ -2893,27 +2065,10 @@ class OceanNpAutoscalerResourceLimitsArgs:
def __init__(__self__, *,
max_memory_gib: Optional[pulumi.Input[int]] = None,
max_vcpu: Optional[pulumi.Input[int]] = None):
- OceanNpAutoscalerResourceLimitsArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- max_memory_gib=max_memory_gib,
- max_vcpu=max_vcpu,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- max_memory_gib: Optional[pulumi.Input[int]] = None,
- max_vcpu: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if max_memory_gib is None and 'maxMemoryGib' in kwargs:
- max_memory_gib = kwargs['maxMemoryGib']
- if max_vcpu is None and 'maxVcpu' in kwargs:
- max_vcpu = kwargs['maxVcpu']
-
if max_memory_gib is not None:
- _setter("max_memory_gib", max_memory_gib)
+ pulumi.set(__self__, "max_memory_gib", max_memory_gib)
if max_vcpu is not None:
- _setter("max_vcpu", max_vcpu)
+ pulumi.set(__self__, "max_vcpu", max_vcpu)
@property
@pulumi.getter(name="maxMemoryGib")
@@ -2951,95 +2106,34 @@ def __init__(__self__, *,
min_vcpu: Optional[pulumi.Input[int]] = None,
series: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
vm_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
- OceanNpFiltersArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- accelerated_networking=accelerated_networking,
- architectures=architectures,
- disk_performance=disk_performance,
- exclude_series=exclude_series,
- max_gpu=max_gpu,
- max_memory_gib=max_memory_gib,
- max_vcpu=max_vcpu,
- min_data=min_data,
- min_gpu=min_gpu,
- min_memory_gib=min_memory_gib,
- min_nics=min_nics,
- min_vcpu=min_vcpu,
- series=series,
- vm_types=vm_types,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- accelerated_networking: Optional[pulumi.Input[str]] = None,
- architectures: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- disk_performance: Optional[pulumi.Input[str]] = None,
- exclude_series: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- max_gpu: Optional[pulumi.Input[float]] = None,
- max_memory_gib: Optional[pulumi.Input[float]] = None,
- max_vcpu: Optional[pulumi.Input[int]] = None,
- min_data: Optional[pulumi.Input[int]] = None,
- min_gpu: Optional[pulumi.Input[float]] = None,
- min_memory_gib: Optional[pulumi.Input[float]] = None,
- min_nics: Optional[pulumi.Input[int]] = None,
- min_vcpu: Optional[pulumi.Input[int]] = None,
- series: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- vm_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if accelerated_networking is None and 'acceleratedNetworking' in kwargs:
- accelerated_networking = kwargs['acceleratedNetworking']
- if disk_performance is None and 'diskPerformance' in kwargs:
- disk_performance = kwargs['diskPerformance']
- if exclude_series is None and 'excludeSeries' in kwargs:
- exclude_series = kwargs['excludeSeries']
- if max_gpu is None and 'maxGpu' in kwargs:
- max_gpu = kwargs['maxGpu']
- if max_memory_gib is None and 'maxMemoryGib' in kwargs:
- max_memory_gib = kwargs['maxMemoryGib']
- if max_vcpu is None and 'maxVcpu' in kwargs:
- max_vcpu = kwargs['maxVcpu']
- if min_data is None and 'minData' in kwargs:
- min_data = kwargs['minData']
- if min_gpu is None and 'minGpu' in kwargs:
- min_gpu = kwargs['minGpu']
- if min_memory_gib is None and 'minMemoryGib' in kwargs:
- min_memory_gib = kwargs['minMemoryGib']
- if min_nics is None and 'minNics' in kwargs:
- min_nics = kwargs['minNics']
- if min_vcpu is None and 'minVcpu' in kwargs:
- min_vcpu = kwargs['minVcpu']
- if vm_types is None and 'vmTypes' in kwargs:
- vm_types = kwargs['vmTypes']
-
if accelerated_networking is not None:
- _setter("accelerated_networking", accelerated_networking)
+ pulumi.set(__self__, "accelerated_networking", accelerated_networking)
if architectures is not None:
- _setter("architectures", architectures)
+ pulumi.set(__self__, "architectures", architectures)
if disk_performance is not None:
- _setter("disk_performance", disk_performance)
+ pulumi.set(__self__, "disk_performance", disk_performance)
if exclude_series is not None:
- _setter("exclude_series", exclude_series)
+ pulumi.set(__self__, "exclude_series", exclude_series)
if max_gpu is not None:
- _setter("max_gpu", max_gpu)
+ pulumi.set(__self__, "max_gpu", max_gpu)
if max_memory_gib is not None:
- _setter("max_memory_gib", max_memory_gib)
+ pulumi.set(__self__, "max_memory_gib", max_memory_gib)
if max_vcpu is not None:
- _setter("max_vcpu", max_vcpu)
+ pulumi.set(__self__, "max_vcpu", max_vcpu)
if min_data is not None:
- _setter("min_data", min_data)
+ pulumi.set(__self__, "min_data", min_data)
if min_gpu is not None:
- _setter("min_gpu", min_gpu)
+ pulumi.set(__self__, "min_gpu", min_gpu)
if min_memory_gib is not None:
- _setter("min_memory_gib", min_memory_gib)
+ pulumi.set(__self__, "min_memory_gib", min_memory_gib)
if min_nics is not None:
- _setter("min_nics", min_nics)
+ pulumi.set(__self__, "min_nics", min_nics)
if min_vcpu is not None:
- _setter("min_vcpu", min_vcpu)
+ pulumi.set(__self__, "min_vcpu", min_vcpu)
if series is not None:
- _setter("series", series)
+ pulumi.set(__self__, "series", series)
if vm_types is not None:
- _setter("vm_types", vm_types)
+ pulumi.set(__self__, "vm_types", vm_types)
@property
@pulumi.getter(name="acceleratedNetworking")
@@ -3175,39 +2269,14 @@ def __init__(__self__, *,
gpu_per_unit: Optional[pulumi.Input[int]] = None,
memory_per_unit: Optional[pulumi.Input[int]] = None,
num_of_units: Optional[pulumi.Input[int]] = None):
- OceanNpHeadroomArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cpu_per_unit=cpu_per_unit,
- gpu_per_unit=gpu_per_unit,
- memory_per_unit=memory_per_unit,
- num_of_units=num_of_units,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cpu_per_unit: Optional[pulumi.Input[int]] = None,
- gpu_per_unit: Optional[pulumi.Input[int]] = None,
- memory_per_unit: Optional[pulumi.Input[int]] = None,
- num_of_units: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cpu_per_unit is None and 'cpuPerUnit' in kwargs:
- cpu_per_unit = kwargs['cpuPerUnit']
- if gpu_per_unit is None and 'gpuPerUnit' in kwargs:
- gpu_per_unit = kwargs['gpuPerUnit']
- if memory_per_unit is None and 'memoryPerUnit' in kwargs:
- memory_per_unit = kwargs['memoryPerUnit']
- if num_of_units is None and 'numOfUnits' in kwargs:
- num_of_units = kwargs['numOfUnits']
-
if cpu_per_unit is not None:
- _setter("cpu_per_unit", cpu_per_unit)
+ pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
if gpu_per_unit is not None:
- _setter("gpu_per_unit", gpu_per_unit)
+ pulumi.set(__self__, "gpu_per_unit", gpu_per_unit)
if memory_per_unit is not None:
- _setter("memory_per_unit", memory_per_unit)
+ pulumi.set(__self__, "memory_per_unit", memory_per_unit)
if num_of_units is not None:
- _setter("num_of_units", num_of_units)
+ pulumi.set(__self__, "num_of_units", num_of_units)
@property
@pulumi.getter(name="cpuPerUnit")
@@ -3250,21 +2319,8 @@ def num_of_units(self, value: Optional[pulumi.Input[int]]):
class OceanNpHealthArgs:
def __init__(__self__, *,
grace_period: Optional[pulumi.Input[int]] = None):
- OceanNpHealthArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- grace_period=grace_period,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- grace_period: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if grace_period is None and 'gracePeriod' in kwargs:
- grace_period = kwargs['gracePeriod']
-
if grace_period is not None:
- _setter("grace_period", grace_period)
+ pulumi.set(__self__, "grace_period", grace_period)
@property
@pulumi.getter(name="gracePeriod")
@@ -3280,21 +2336,8 @@ def grace_period(self, value: Optional[pulumi.Input[int]]):
class OceanNpSchedulingArgs:
def __init__(__self__, *,
shutdown_hours: Optional[pulumi.Input['OceanNpSchedulingShutdownHoursArgs']] = None):
- OceanNpSchedulingArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- shutdown_hours=shutdown_hours,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- shutdown_hours: Optional[pulumi.Input['OceanNpSchedulingShutdownHoursArgs']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if shutdown_hours is None and 'shutdownHours' in kwargs:
- shutdown_hours = kwargs['shutdownHours']
-
if shutdown_hours is not None:
- _setter("shutdown_hours", shutdown_hours)
+ pulumi.set(__self__, "shutdown_hours", shutdown_hours)
@property
@pulumi.getter(name="shutdownHours")
@@ -3311,28 +2354,9 @@ class OceanNpSchedulingShutdownHoursArgs:
def __init__(__self__, *,
time_windows: pulumi.Input[Sequence[pulumi.Input[str]]],
is_enabled: Optional[pulumi.Input[bool]] = None):
- OceanNpSchedulingShutdownHoursArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- time_windows=time_windows,
- is_enabled=is_enabled,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- time_windows: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- is_enabled: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if time_windows is None and 'timeWindows' in kwargs:
- time_windows = kwargs['timeWindows']
- if time_windows is None:
- raise TypeError("Missing 'time_windows' argument")
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
-
- _setter("time_windows", time_windows)
+ pulumi.set(__self__, "time_windows", time_windows)
if is_enabled is not None:
- _setter("is_enabled", is_enabled)
+ pulumi.set(__self__, "is_enabled", is_enabled)
@property
@pulumi.getter(name="timeWindows")
@@ -3359,30 +2383,9 @@ def __init__(__self__, *,
effect: pulumi.Input[str],
key: pulumi.Input[str],
value: pulumi.Input[str]):
- OceanNpTaintArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- effect=effect,
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- effect: Optional[pulumi.Input[str]] = None,
- key: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if effect is None:
- raise TypeError("Missing 'effect' argument")
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("effect", effect)
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "effect", effect)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -3429,95 +2432,34 @@ def __init__(__self__, *,
min_vcpu: Optional[pulumi.Input[int]] = None,
series: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
vm_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
- OceanNpVirtualNodeGroupFiltersArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- accelerated_networking=accelerated_networking,
- architectures=architectures,
- disk_performance=disk_performance,
- exclude_series=exclude_series,
- max_gpu=max_gpu,
- max_memory_gib=max_memory_gib,
- max_vcpu=max_vcpu,
- min_data=min_data,
- min_gpu=min_gpu,
- min_memory_gib=min_memory_gib,
- min_nics=min_nics,
- min_vcpu=min_vcpu,
- series=series,
- vm_types=vm_types,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- accelerated_networking: Optional[pulumi.Input[str]] = None,
- architectures: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- disk_performance: Optional[pulumi.Input[str]] = None,
- exclude_series: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- max_gpu: Optional[pulumi.Input[float]] = None,
- max_memory_gib: Optional[pulumi.Input[float]] = None,
- max_vcpu: Optional[pulumi.Input[int]] = None,
- min_data: Optional[pulumi.Input[int]] = None,
- min_gpu: Optional[pulumi.Input[float]] = None,
- min_memory_gib: Optional[pulumi.Input[float]] = None,
- min_nics: Optional[pulumi.Input[int]] = None,
- min_vcpu: Optional[pulumi.Input[int]] = None,
- series: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- vm_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if accelerated_networking is None and 'acceleratedNetworking' in kwargs:
- accelerated_networking = kwargs['acceleratedNetworking']
- if disk_performance is None and 'diskPerformance' in kwargs:
- disk_performance = kwargs['diskPerformance']
- if exclude_series is None and 'excludeSeries' in kwargs:
- exclude_series = kwargs['excludeSeries']
- if max_gpu is None and 'maxGpu' in kwargs:
- max_gpu = kwargs['maxGpu']
- if max_memory_gib is None and 'maxMemoryGib' in kwargs:
- max_memory_gib = kwargs['maxMemoryGib']
- if max_vcpu is None and 'maxVcpu' in kwargs:
- max_vcpu = kwargs['maxVcpu']
- if min_data is None and 'minData' in kwargs:
- min_data = kwargs['minData']
- if min_gpu is None and 'minGpu' in kwargs:
- min_gpu = kwargs['minGpu']
- if min_memory_gib is None and 'minMemoryGib' in kwargs:
- min_memory_gib = kwargs['minMemoryGib']
- if min_nics is None and 'minNics' in kwargs:
- min_nics = kwargs['minNics']
- if min_vcpu is None and 'minVcpu' in kwargs:
- min_vcpu = kwargs['minVcpu']
- if vm_types is None and 'vmTypes' in kwargs:
- vm_types = kwargs['vmTypes']
-
if accelerated_networking is not None:
- _setter("accelerated_networking", accelerated_networking)
+ pulumi.set(__self__, "accelerated_networking", accelerated_networking)
if architectures is not None:
- _setter("architectures", architectures)
+ pulumi.set(__self__, "architectures", architectures)
if disk_performance is not None:
- _setter("disk_performance", disk_performance)
+ pulumi.set(__self__, "disk_performance", disk_performance)
if exclude_series is not None:
- _setter("exclude_series", exclude_series)
+ pulumi.set(__self__, "exclude_series", exclude_series)
if max_gpu is not None:
- _setter("max_gpu", max_gpu)
+ pulumi.set(__self__, "max_gpu", max_gpu)
if max_memory_gib is not None:
- _setter("max_memory_gib", max_memory_gib)
+ pulumi.set(__self__, "max_memory_gib", max_memory_gib)
if max_vcpu is not None:
- _setter("max_vcpu", max_vcpu)
+ pulumi.set(__self__, "max_vcpu", max_vcpu)
if min_data is not None:
- _setter("min_data", min_data)
+ pulumi.set(__self__, "min_data", min_data)
if min_gpu is not None:
- _setter("min_gpu", min_gpu)
+ pulumi.set(__self__, "min_gpu", min_gpu)
if min_memory_gib is not None:
- _setter("min_memory_gib", min_memory_gib)
+ pulumi.set(__self__, "min_memory_gib", min_memory_gib)
if min_nics is not None:
- _setter("min_nics", min_nics)
+ pulumi.set(__self__, "min_nics", min_nics)
if min_vcpu is not None:
- _setter("min_vcpu", min_vcpu)
+ pulumi.set(__self__, "min_vcpu", min_vcpu)
if series is not None:
- _setter("series", series)
+ pulumi.set(__self__, "series", series)
if vm_types is not None:
- _setter("vm_types", vm_types)
+ pulumi.set(__self__, "vm_types", vm_types)
@property
@pulumi.getter(name="acceleratedNetworking")
@@ -3653,39 +2595,14 @@ def __init__(__self__, *,
gpu_per_unit: Optional[pulumi.Input[int]] = None,
memory_per_unit: Optional[pulumi.Input[int]] = None,
num_of_units: Optional[pulumi.Input[int]] = None):
- OceanNpVirtualNodeGroupHeadroomArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cpu_per_unit=cpu_per_unit,
- gpu_per_unit=gpu_per_unit,
- memory_per_unit=memory_per_unit,
- num_of_units=num_of_units,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cpu_per_unit: Optional[pulumi.Input[int]] = None,
- gpu_per_unit: Optional[pulumi.Input[int]] = None,
- memory_per_unit: Optional[pulumi.Input[int]] = None,
- num_of_units: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cpu_per_unit is None and 'cpuPerUnit' in kwargs:
- cpu_per_unit = kwargs['cpuPerUnit']
- if gpu_per_unit is None and 'gpuPerUnit' in kwargs:
- gpu_per_unit = kwargs['gpuPerUnit']
- if memory_per_unit is None and 'memoryPerUnit' in kwargs:
- memory_per_unit = kwargs['memoryPerUnit']
- if num_of_units is None and 'numOfUnits' in kwargs:
- num_of_units = kwargs['numOfUnits']
-
if cpu_per_unit is not None:
- _setter("cpu_per_unit", cpu_per_unit)
+ pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
if gpu_per_unit is not None:
- _setter("gpu_per_unit", gpu_per_unit)
+ pulumi.set(__self__, "gpu_per_unit", gpu_per_unit)
if memory_per_unit is not None:
- _setter("memory_per_unit", memory_per_unit)
+ pulumi.set(__self__, "memory_per_unit", memory_per_unit)
if num_of_units is not None:
- _setter("num_of_units", num_of_units)
+ pulumi.set(__self__, "num_of_units", num_of_units)
@property
@pulumi.getter(name="cpuPerUnit")
@@ -3730,30 +2647,9 @@ def __init__(__self__, *,
effect: pulumi.Input[str],
key: pulumi.Input[str],
value: pulumi.Input[str]):
- OceanNpVirtualNodeGroupTaintArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- effect=effect,
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- effect: Optional[pulumi.Input[str]] = None,
- key: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if effect is None:
- raise TypeError("Missing 'effect' argument")
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("effect", effect)
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "effect", effect)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -3792,26 +2688,9 @@ def __init__(__self__, *,
:param pulumi.Input[int] size_gb: The size of the OS disk in GB.
:param pulumi.Input[str] type: The type of load balancer. Supported value: `loadBalancer`
"""
- OceanOsDiskArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- size_gb=size_gb,
- type=type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- size_gb: Optional[pulumi.Input[int]] = None,
- type: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if size_gb is None and 'sizeGb' in kwargs:
- size_gb = kwargs['sizeGb']
- if size_gb is None:
- raise TypeError("Missing 'size_gb' argument")
-
- _setter("size_gb", size_gb)
+ pulumi.set(__self__, "size_gb", size_gb)
if type is not None:
- _setter("type", type)
+ pulumi.set(__self__, "type", type)
@property
@pulumi.getter(name="sizeGb")
@@ -3847,27 +2726,10 @@ def __init__(__self__, *,
:param pulumi.Input[bool] fallback_to_ondemand: If no spot instance markets are available, enable Ocean to launch on-demand instances instead.
:param pulumi.Input[int] spot_percentage: Percentage of Spot VMs to maintain.
"""
- OceanStrategyArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- fallback_to_ondemand=fallback_to_ondemand,
- spot_percentage=spot_percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- fallback_to_ondemand: Optional[pulumi.Input[bool]] = None,
- spot_percentage: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if fallback_to_ondemand is None and 'fallbackToOndemand' in kwargs:
- fallback_to_ondemand = kwargs['fallbackToOndemand']
- if spot_percentage is None and 'spotPercentage' in kwargs:
- spot_percentage = kwargs['spotPercentage']
-
if fallback_to_ondemand is not None:
- _setter("fallback_to_ondemand", fallback_to_ondemand)
+ pulumi.set(__self__, "fallback_to_ondemand", fallback_to_ondemand)
if spot_percentage is not None:
- _setter("spot_percentage", spot_percentage)
+ pulumi.set(__self__, "spot_percentage", spot_percentage)
@property
@pulumi.getter(name="fallbackToOndemand")
@@ -3903,23 +2765,10 @@ def __init__(__self__, *,
:param pulumi.Input[str] key: Tag key.
:param pulumi.Input[str] value: Tag value.
"""
- OceanTagArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if key is not None:
- _setter("key", key)
+ pulumi.set(__self__, "key", key)
if value is not None:
- _setter("value", value)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -3954,27 +2803,10 @@ def __init__(__self__, *,
"""
:param pulumi.Input[int] auto_headroom_percentage: Number between 0-200 to control the headroom % of the specific Virtual Node Group. Effective when `cluster.autoScaler.headroom.automatic.is_enabled` = true is set on the Ocean cluster.
"""
- OceanVirtualNodeGroupAutoscaleArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- auto_headroom_percentage=auto_headroom_percentage,
- autoscale_headrooms=autoscale_headrooms,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- auto_headroom_percentage: Optional[pulumi.Input[int]] = None,
- autoscale_headrooms: Optional[pulumi.Input[Sequence[pulumi.Input['OceanVirtualNodeGroupAutoscaleAutoscaleHeadroomArgs']]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if auto_headroom_percentage is None and 'autoHeadroomPercentage' in kwargs:
- auto_headroom_percentage = kwargs['autoHeadroomPercentage']
- if autoscale_headrooms is None and 'autoscaleHeadrooms' in kwargs:
- autoscale_headrooms = kwargs['autoscaleHeadrooms']
-
if auto_headroom_percentage is not None:
- _setter("auto_headroom_percentage", auto_headroom_percentage)
+ pulumi.set(__self__, "auto_headroom_percentage", auto_headroom_percentage)
if autoscale_headrooms is not None:
- _setter("autoscale_headrooms", autoscale_headrooms)
+ pulumi.set(__self__, "autoscale_headrooms", autoscale_headrooms)
@property
@pulumi.getter(name="autoHeadroomPercentage")
@@ -4011,40 +2843,13 @@ def __init__(__self__, *,
:param pulumi.Input[int] gpu_per_unit: How many GPU cores should be allocated for headroom unit.
:param pulumi.Input[int] memory_per_unit: Configure the amount of memory (MiB) to allocate the headroom.
"""
- OceanVirtualNodeGroupAutoscaleAutoscaleHeadroomArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- num_of_units=num_of_units,
- cpu_per_unit=cpu_per_unit,
- gpu_per_unit=gpu_per_unit,
- memory_per_unit=memory_per_unit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- num_of_units: Optional[pulumi.Input[int]] = None,
- cpu_per_unit: Optional[pulumi.Input[int]] = None,
- gpu_per_unit: Optional[pulumi.Input[int]] = None,
- memory_per_unit: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if num_of_units is None and 'numOfUnits' in kwargs:
- num_of_units = kwargs['numOfUnits']
- if num_of_units is None:
- raise TypeError("Missing 'num_of_units' argument")
- if cpu_per_unit is None and 'cpuPerUnit' in kwargs:
- cpu_per_unit = kwargs['cpuPerUnit']
- if gpu_per_unit is None and 'gpuPerUnit' in kwargs:
- gpu_per_unit = kwargs['gpuPerUnit']
- if memory_per_unit is None and 'memoryPerUnit' in kwargs:
- memory_per_unit = kwargs['memoryPerUnit']
-
- _setter("num_of_units", num_of_units)
+ pulumi.set(__self__, "num_of_units", num_of_units)
if cpu_per_unit is not None:
- _setter("cpu_per_unit", cpu_per_unit)
+ pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
if gpu_per_unit is not None:
- _setter("gpu_per_unit", gpu_per_unit)
+ pulumi.set(__self__, "gpu_per_unit", gpu_per_unit)
if memory_per_unit is not None:
- _setter("memory_per_unit", memory_per_unit)
+ pulumi.set(__self__, "memory_per_unit", memory_per_unit)
@property
@pulumi.getter(name="numOfUnits")
@@ -4104,24 +2909,9 @@ def __init__(__self__, *,
:param pulumi.Input[str] key: Tag Key for Vms in the cluster.
:param pulumi.Input[str] value: Tag Value for VMs in the cluster.
"""
- OceanVirtualNodeGroupLabelArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
-
- _setter("key", key)
+ pulumi.set(__self__, "key", key)
if value is not None:
- _setter("value", value)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -4159,31 +2949,12 @@ def __init__(__self__, *,
:param pulumi.Input['OceanVirtualNodeGroupLaunchSpecificationOsDiskArgs'] os_disk: Specify OS disk specification other than default.
:param pulumi.Input[Sequence[pulumi.Input['OceanVirtualNodeGroupLaunchSpecificationTagArgs']]] tags: Additional key-value pairs to be used to tag the VMs in the virtual node group.
"""
- OceanVirtualNodeGroupLaunchSpecificationArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- max_pods=max_pods,
- os_disk=os_disk,
- tags=tags,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- max_pods: Optional[pulumi.Input[int]] = None,
- os_disk: Optional[pulumi.Input['OceanVirtualNodeGroupLaunchSpecificationOsDiskArgs']] = None,
- tags: Optional[pulumi.Input[Sequence[pulumi.Input['OceanVirtualNodeGroupLaunchSpecificationTagArgs']]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if max_pods is None and 'maxPods' in kwargs:
- max_pods = kwargs['maxPods']
- if os_disk is None and 'osDisk' in kwargs:
- os_disk = kwargs['osDisk']
-
if max_pods is not None:
- _setter("max_pods", max_pods)
+ pulumi.set(__self__, "max_pods", max_pods)
if os_disk is not None:
- _setter("os_disk", os_disk)
+ pulumi.set(__self__, "os_disk", os_disk)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
@property
@pulumi.getter(name="maxPods")
@@ -4233,32 +3004,11 @@ def __init__(__self__, *,
:param pulumi.Input[str] type: The type of the OS disk. Valid values: `"Standard_LRS"`, `"Premium_LRS"`, `"StandardSSD_LRS"`.
:param pulumi.Input[bool] utilize_ephemeral_storage: Flag to enable/disable the Ephemeral OS Disk utilization.
"""
- OceanVirtualNodeGroupLaunchSpecificationOsDiskArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- size_gb=size_gb,
- type=type,
- utilize_ephemeral_storage=utilize_ephemeral_storage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- size_gb: Optional[pulumi.Input[int]] = None,
- type: Optional[pulumi.Input[str]] = None,
- utilize_ephemeral_storage: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if size_gb is None and 'sizeGb' in kwargs:
- size_gb = kwargs['sizeGb']
- if size_gb is None:
- raise TypeError("Missing 'size_gb' argument")
- if utilize_ephemeral_storage is None and 'utilizeEphemeralStorage' in kwargs:
- utilize_ephemeral_storage = kwargs['utilizeEphemeralStorage']
-
- _setter("size_gb", size_gb)
+ pulumi.set(__self__, "size_gb", size_gb)
if type is not None:
- _setter("type", type)
+ pulumi.set(__self__, "type", type)
if utilize_ephemeral_storage is not None:
- _setter("utilize_ephemeral_storage", utilize_ephemeral_storage)
+ pulumi.set(__self__, "utilize_ephemeral_storage", utilize_ephemeral_storage)
@property
@pulumi.getter(name="sizeGb")
@@ -4306,23 +3056,10 @@ def __init__(__self__, *,
:param pulumi.Input[str] key: Tag Key for Vms in the cluster.
:param pulumi.Input[str] value: Tag Value for VMs in the cluster.
"""
- OceanVirtualNodeGroupLaunchSpecificationTagArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if key is not None:
- _setter("key", key)
+ pulumi.set(__self__, "key", key)
if value is not None:
- _setter("value", value)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -4356,21 +3093,8 @@ def __init__(__self__, *,
"""
:param pulumi.Input[int] max_instance_count: Option to set a maximum number of instances per virtual node group. If set, value must be greater than or equal to 0.
"""
- OceanVirtualNodeGroupResourceLimitArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- max_instance_count=max_instance_count,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- max_instance_count: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if max_instance_count is None and 'maxInstanceCount' in kwargs:
- max_instance_count = kwargs['maxInstanceCount']
-
if max_instance_count is not None:
- _setter("max_instance_count", max_instance_count)
+ pulumi.set(__self__, "max_instance_count", max_instance_count)
@property
@pulumi.getter(name="maxInstanceCount")
@@ -4396,30 +3120,9 @@ def __init__(__self__, *,
:param pulumi.Input[str] key: Tag Key for Vms in the cluster.
:param pulumi.Input[str] value: Tag Value for VMs in the cluster.
"""
- OceanVirtualNodeGroupTaintArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- effect=effect,
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- effect: Optional[pulumi.Input[str]] = None,
- key: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if effect is None:
- raise TypeError("Missing 'effect' argument")
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("effect", effect)
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "effect", effect)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -4465,19 +3168,8 @@ def __init__(__self__, *,
"""
:param pulumi.Input[Sequence[pulumi.Input[str]]] whitelists: VM types allowed in the Ocean cluster.
"""
- OceanVmSizeArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- whitelists=whitelists,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if whitelists is not None:
- _setter("whitelists", whitelists)
+ pulumi.set(__self__, "whitelists", whitelists)
@property
@pulumi.getter
diff --git a/sdk/python/pulumi_spotinst/azure/elastigroup.py b/sdk/python/pulumi_spotinst/azure/elastigroup.py
index 8867d675..a656549c 100644
--- a/sdk/python/pulumi_spotinst/azure/elastigroup.py
+++ b/sdk/python/pulumi_spotinst/azure/elastigroup.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs
from ._inputs import *
@@ -52,158 +52,49 @@ def __init__(__self__, *,
:param pulumi.Input[int] min_size: The minimum number of instances the group should have at any time.
:param pulumi.Input[str] name: Name of the Managed Service Identity.
"""
- ElastigroupArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- low_priority_sizes=low_priority_sizes,
- network=network,
- od_sizes=od_sizes,
- product=product,
- region=region,
- resource_group_name=resource_group_name,
- strategy=strategy,
- custom_data=custom_data,
- desired_capacity=desired_capacity,
- health_check=health_check,
- images=images,
- integration_kubernetes=integration_kubernetes,
- integration_multai_runtime=integration_multai_runtime,
- load_balancers=load_balancers,
- login=login,
- managed_service_identities=managed_service_identities,
- max_size=max_size,
- min_size=min_size,
- name=name,
- scaling_down_policies=scaling_down_policies,
- scaling_up_policies=scaling_up_policies,
- scheduled_tasks=scheduled_tasks,
- shutdown_script=shutdown_script,
- update_policy=update_policy,
- user_data=user_data,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- low_priority_sizes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- network: Optional[pulumi.Input['ElastigroupNetworkArgs']] = None,
- od_sizes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- product: Optional[pulumi.Input[str]] = None,
- region: Optional[pulumi.Input[str]] = None,
- resource_group_name: Optional[pulumi.Input[str]] = None,
- strategy: Optional[pulumi.Input['ElastigroupStrategyArgs']] = None,
- custom_data: Optional[pulumi.Input[str]] = None,
- desired_capacity: Optional[pulumi.Input[int]] = None,
- health_check: Optional[pulumi.Input['ElastigroupHealthCheckArgs']] = None,
- images: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupImageArgs']]]] = None,
- integration_kubernetes: Optional[pulumi.Input['ElastigroupIntegrationKubernetesArgs']] = None,
- integration_multai_runtime: Optional[pulumi.Input['ElastigroupIntegrationMultaiRuntimeArgs']] = None,
- load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupLoadBalancerArgs']]]] = None,
- login: Optional[pulumi.Input['ElastigroupLoginArgs']] = None,
- managed_service_identities: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupManagedServiceIdentityArgs']]]] = None,
- max_size: Optional[pulumi.Input[int]] = None,
- min_size: Optional[pulumi.Input[int]] = None,
- name: Optional[pulumi.Input[str]] = None,
- scaling_down_policies: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyArgs']]]] = None,
- scaling_up_policies: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyArgs']]]] = None,
- scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScheduledTaskArgs']]]] = None,
- shutdown_script: Optional[pulumi.Input[str]] = None,
- update_policy: Optional[pulumi.Input['ElastigroupUpdatePolicyArgs']] = None,
- user_data: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if low_priority_sizes is None and 'lowPrioritySizes' in kwargs:
- low_priority_sizes = kwargs['lowPrioritySizes']
- if low_priority_sizes is None:
- raise TypeError("Missing 'low_priority_sizes' argument")
- if network is None:
- raise TypeError("Missing 'network' argument")
- if od_sizes is None and 'odSizes' in kwargs:
- od_sizes = kwargs['odSizes']
- if od_sizes is None:
- raise TypeError("Missing 'od_sizes' argument")
- if product is None:
- raise TypeError("Missing 'product' argument")
- if region is None:
- raise TypeError("Missing 'region' argument")
- if resource_group_name is None and 'resourceGroupName' in kwargs:
- resource_group_name = kwargs['resourceGroupName']
- if resource_group_name is None:
- raise TypeError("Missing 'resource_group_name' argument")
- if strategy is None:
- raise TypeError("Missing 'strategy' argument")
- if custom_data is None and 'customData' in kwargs:
- custom_data = kwargs['customData']
- if desired_capacity is None and 'desiredCapacity' in kwargs:
- desired_capacity = kwargs['desiredCapacity']
- if health_check is None and 'healthCheck' in kwargs:
- health_check = kwargs['healthCheck']
- if integration_kubernetes is None and 'integrationKubernetes' in kwargs:
- integration_kubernetes = kwargs['integrationKubernetes']
- if integration_multai_runtime is None and 'integrationMultaiRuntime' in kwargs:
- integration_multai_runtime = kwargs['integrationMultaiRuntime']
- if load_balancers is None and 'loadBalancers' in kwargs:
- load_balancers = kwargs['loadBalancers']
- if managed_service_identities is None and 'managedServiceIdentities' in kwargs:
- managed_service_identities = kwargs['managedServiceIdentities']
- if max_size is None and 'maxSize' in kwargs:
- max_size = kwargs['maxSize']
- if min_size is None and 'minSize' in kwargs:
- min_size = kwargs['minSize']
- if scaling_down_policies is None and 'scalingDownPolicies' in kwargs:
- scaling_down_policies = kwargs['scalingDownPolicies']
- if scaling_up_policies is None and 'scalingUpPolicies' in kwargs:
- scaling_up_policies = kwargs['scalingUpPolicies']
- if scheduled_tasks is None and 'scheduledTasks' in kwargs:
- scheduled_tasks = kwargs['scheduledTasks']
- if shutdown_script is None and 'shutdownScript' in kwargs:
- shutdown_script = kwargs['shutdownScript']
- if update_policy is None and 'updatePolicy' in kwargs:
- update_policy = kwargs['updatePolicy']
- if user_data is None and 'userData' in kwargs:
- user_data = kwargs['userData']
-
- _setter("low_priority_sizes", low_priority_sizes)
- _setter("network", network)
- _setter("od_sizes", od_sizes)
- _setter("product", product)
- _setter("region", region)
- _setter("resource_group_name", resource_group_name)
- _setter("strategy", strategy)
+ pulumi.set(__self__, "low_priority_sizes", low_priority_sizes)
+ pulumi.set(__self__, "network", network)
+ pulumi.set(__self__, "od_sizes", od_sizes)
+ pulumi.set(__self__, "product", product)
+ pulumi.set(__self__, "region", region)
+ pulumi.set(__self__, "resource_group_name", resource_group_name)
+ pulumi.set(__self__, "strategy", strategy)
if custom_data is not None:
- _setter("custom_data", custom_data)
+ pulumi.set(__self__, "custom_data", custom_data)
if desired_capacity is not None:
- _setter("desired_capacity", desired_capacity)
+ pulumi.set(__self__, "desired_capacity", desired_capacity)
if health_check is not None:
- _setter("health_check", health_check)
+ pulumi.set(__self__, "health_check", health_check)
if images is not None:
- _setter("images", images)
+ pulumi.set(__self__, "images", images)
if integration_kubernetes is not None:
- _setter("integration_kubernetes", integration_kubernetes)
+ pulumi.set(__self__, "integration_kubernetes", integration_kubernetes)
if integration_multai_runtime is not None:
- _setter("integration_multai_runtime", integration_multai_runtime)
+ pulumi.set(__self__, "integration_multai_runtime", integration_multai_runtime)
if load_balancers is not None:
- _setter("load_balancers", load_balancers)
+ pulumi.set(__self__, "load_balancers", load_balancers)
if login is not None:
- _setter("login", login)
+ pulumi.set(__self__, "login", login)
if managed_service_identities is not None:
- _setter("managed_service_identities", managed_service_identities)
+ pulumi.set(__self__, "managed_service_identities", managed_service_identities)
if max_size is not None:
- _setter("max_size", max_size)
+ pulumi.set(__self__, "max_size", max_size)
if min_size is not None:
- _setter("min_size", min_size)
+ pulumi.set(__self__, "min_size", min_size)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if scaling_down_policies is not None:
- _setter("scaling_down_policies", scaling_down_policies)
+ pulumi.set(__self__, "scaling_down_policies", scaling_down_policies)
if scaling_up_policies is not None:
- _setter("scaling_up_policies", scaling_up_policies)
+ pulumi.set(__self__, "scaling_up_policies", scaling_up_policies)
if scheduled_tasks is not None:
- _setter("scheduled_tasks", scheduled_tasks)
+ pulumi.set(__self__, "scheduled_tasks", scheduled_tasks)
if shutdown_script is not None:
- _setter("shutdown_script", shutdown_script)
+ pulumi.set(__self__, "shutdown_script", shutdown_script)
if update_policy is not None:
- _setter("update_policy", update_policy)
+ pulumi.set(__self__, "update_policy", update_policy)
if user_data is not None:
- _setter("user_data", user_data)
+ pulumi.set(__self__, "user_data", user_data)
@property
@pulumi.getter(name="lowPrioritySizes")
@@ -494,151 +385,56 @@ def __init__(__self__, *,
:param pulumi.Input[str] region: The region your Azure group will be created in.
:param pulumi.Input[str] resource_group_name: Name of the Azure Resource Group where the Managed Service Identity is located.
"""
- _ElastigroupState._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- custom_data=custom_data,
- desired_capacity=desired_capacity,
- health_check=health_check,
- images=images,
- integration_kubernetes=integration_kubernetes,
- integration_multai_runtime=integration_multai_runtime,
- load_balancers=load_balancers,
- login=login,
- low_priority_sizes=low_priority_sizes,
- managed_service_identities=managed_service_identities,
- max_size=max_size,
- min_size=min_size,
- name=name,
- network=network,
- od_sizes=od_sizes,
- product=product,
- region=region,
- resource_group_name=resource_group_name,
- scaling_down_policies=scaling_down_policies,
- scaling_up_policies=scaling_up_policies,
- scheduled_tasks=scheduled_tasks,
- shutdown_script=shutdown_script,
- strategy=strategy,
- update_policy=update_policy,
- user_data=user_data,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- custom_data: Optional[pulumi.Input[str]] = None,
- desired_capacity: Optional[pulumi.Input[int]] = None,
- health_check: Optional[pulumi.Input['ElastigroupHealthCheckArgs']] = None,
- images: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupImageArgs']]]] = None,
- integration_kubernetes: Optional[pulumi.Input['ElastigroupIntegrationKubernetesArgs']] = None,
- integration_multai_runtime: Optional[pulumi.Input['ElastigroupIntegrationMultaiRuntimeArgs']] = None,
- load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupLoadBalancerArgs']]]] = None,
- login: Optional[pulumi.Input['ElastigroupLoginArgs']] = None,
- low_priority_sizes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- managed_service_identities: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupManagedServiceIdentityArgs']]]] = None,
- max_size: Optional[pulumi.Input[int]] = None,
- min_size: Optional[pulumi.Input[int]] = None,
- name: Optional[pulumi.Input[str]] = None,
- network: Optional[pulumi.Input['ElastigroupNetworkArgs']] = None,
- od_sizes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- product: Optional[pulumi.Input[str]] = None,
- region: Optional[pulumi.Input[str]] = None,
- resource_group_name: Optional[pulumi.Input[str]] = None,
- scaling_down_policies: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyArgs']]]] = None,
- scaling_up_policies: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyArgs']]]] = None,
- scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScheduledTaskArgs']]]] = None,
- shutdown_script: Optional[pulumi.Input[str]] = None,
- strategy: Optional[pulumi.Input['ElastigroupStrategyArgs']] = None,
- update_policy: Optional[pulumi.Input['ElastigroupUpdatePolicyArgs']] = None,
- user_data: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if custom_data is None and 'customData' in kwargs:
- custom_data = kwargs['customData']
- if desired_capacity is None and 'desiredCapacity' in kwargs:
- desired_capacity = kwargs['desiredCapacity']
- if health_check is None and 'healthCheck' in kwargs:
- health_check = kwargs['healthCheck']
- if integration_kubernetes is None and 'integrationKubernetes' in kwargs:
- integration_kubernetes = kwargs['integrationKubernetes']
- if integration_multai_runtime is None and 'integrationMultaiRuntime' in kwargs:
- integration_multai_runtime = kwargs['integrationMultaiRuntime']
- if load_balancers is None and 'loadBalancers' in kwargs:
- load_balancers = kwargs['loadBalancers']
- if low_priority_sizes is None and 'lowPrioritySizes' in kwargs:
- low_priority_sizes = kwargs['lowPrioritySizes']
- if managed_service_identities is None and 'managedServiceIdentities' in kwargs:
- managed_service_identities = kwargs['managedServiceIdentities']
- if max_size is None and 'maxSize' in kwargs:
- max_size = kwargs['maxSize']
- if min_size is None and 'minSize' in kwargs:
- min_size = kwargs['minSize']
- if od_sizes is None and 'odSizes' in kwargs:
- od_sizes = kwargs['odSizes']
- if resource_group_name is None and 'resourceGroupName' in kwargs:
- resource_group_name = kwargs['resourceGroupName']
- if scaling_down_policies is None and 'scalingDownPolicies' in kwargs:
- scaling_down_policies = kwargs['scalingDownPolicies']
- if scaling_up_policies is None and 'scalingUpPolicies' in kwargs:
- scaling_up_policies = kwargs['scalingUpPolicies']
- if scheduled_tasks is None and 'scheduledTasks' in kwargs:
- scheduled_tasks = kwargs['scheduledTasks']
- if shutdown_script is None and 'shutdownScript' in kwargs:
- shutdown_script = kwargs['shutdownScript']
- if update_policy is None and 'updatePolicy' in kwargs:
- update_policy = kwargs['updatePolicy']
- if user_data is None and 'userData' in kwargs:
- user_data = kwargs['userData']
-
if custom_data is not None:
- _setter("custom_data", custom_data)
+ pulumi.set(__self__, "custom_data", custom_data)
if desired_capacity is not None:
- _setter("desired_capacity", desired_capacity)
+ pulumi.set(__self__, "desired_capacity", desired_capacity)
if health_check is not None:
- _setter("health_check", health_check)
+ pulumi.set(__self__, "health_check", health_check)
if images is not None:
- _setter("images", images)
+ pulumi.set(__self__, "images", images)
if integration_kubernetes is not None:
- _setter("integration_kubernetes", integration_kubernetes)
+ pulumi.set(__self__, "integration_kubernetes", integration_kubernetes)
if integration_multai_runtime is not None:
- _setter("integration_multai_runtime", integration_multai_runtime)
+ pulumi.set(__self__, "integration_multai_runtime", integration_multai_runtime)
if load_balancers is not None:
- _setter("load_balancers", load_balancers)
+ pulumi.set(__self__, "load_balancers", load_balancers)
if login is not None:
- _setter("login", login)
+ pulumi.set(__self__, "login", login)
if low_priority_sizes is not None:
- _setter("low_priority_sizes", low_priority_sizes)
+ pulumi.set(__self__, "low_priority_sizes", low_priority_sizes)
if managed_service_identities is not None:
- _setter("managed_service_identities", managed_service_identities)
+ pulumi.set(__self__, "managed_service_identities", managed_service_identities)
if max_size is not None:
- _setter("max_size", max_size)
+ pulumi.set(__self__, "max_size", max_size)
if min_size is not None:
- _setter("min_size", min_size)
+ pulumi.set(__self__, "min_size", min_size)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if network is not None:
- _setter("network", network)
+ pulumi.set(__self__, "network", network)
if od_sizes is not None:
- _setter("od_sizes", od_sizes)
+ pulumi.set(__self__, "od_sizes", od_sizes)
if product is not None:
- _setter("product", product)
+ pulumi.set(__self__, "product", product)
if region is not None:
- _setter("region", region)
+ pulumi.set(__self__, "region", region)
if resource_group_name is not None:
- _setter("resource_group_name", resource_group_name)
+ pulumi.set(__self__, "resource_group_name", resource_group_name)
if scaling_down_policies is not None:
- _setter("scaling_down_policies", scaling_down_policies)
+ pulumi.set(__self__, "scaling_down_policies", scaling_down_policies)
if scaling_up_policies is not None:
- _setter("scaling_up_policies", scaling_up_policies)
+ pulumi.set(__self__, "scaling_up_policies", scaling_up_policies)
if scheduled_tasks is not None:
- _setter("scheduled_tasks", scheduled_tasks)
+ pulumi.set(__self__, "scheduled_tasks", scheduled_tasks)
if shutdown_script is not None:
- _setter("shutdown_script", shutdown_script)
+ pulumi.set(__self__, "shutdown_script", shutdown_script)
if strategy is not None:
- _setter("strategy", strategy)
+ pulumi.set(__self__, "strategy", strategy)
if update_policy is not None:
- _setter("update_policy", update_policy)
+ pulumi.set(__self__, "update_policy", update_policy)
if user_data is not None:
- _setter("user_data", user_data)
+ pulumi.set(__self__, "user_data", user_data)
@property
@pulumi.getter(name="customData")
@@ -1062,10 +858,6 @@ def __init__(__self__, resource_name: str, *args, **kwargs):
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
- kwargs = kwargs or {}
- def _setter(key, value):
- kwargs[key] = value
- ElastigroupArgs._configure(_setter, **kwargs)
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
@@ -1107,15 +899,11 @@ def _internal_init(__self__,
__props__.__dict__["custom_data"] = custom_data
__props__.__dict__["desired_capacity"] = desired_capacity
- health_check = _utilities.configure(health_check, ElastigroupHealthCheckArgs, True)
__props__.__dict__["health_check"] = health_check
__props__.__dict__["images"] = images
- integration_kubernetes = _utilities.configure(integration_kubernetes, ElastigroupIntegrationKubernetesArgs, True)
__props__.__dict__["integration_kubernetes"] = integration_kubernetes
- integration_multai_runtime = _utilities.configure(integration_multai_runtime, ElastigroupIntegrationMultaiRuntimeArgs, True)
__props__.__dict__["integration_multai_runtime"] = integration_multai_runtime
__props__.__dict__["load_balancers"] = load_balancers
- login = _utilities.configure(login, ElastigroupLoginArgs, True)
__props__.__dict__["login"] = login
if low_priority_sizes is None and not opts.urn:
raise TypeError("Missing required property 'low_priority_sizes'")
@@ -1124,7 +912,6 @@ def _internal_init(__self__,
__props__.__dict__["max_size"] = max_size
__props__.__dict__["min_size"] = min_size
__props__.__dict__["name"] = name
- network = _utilities.configure(network, ElastigroupNetworkArgs, True)
if network is None and not opts.urn:
raise TypeError("Missing required property 'network'")
__props__.__dict__["network"] = network
@@ -1144,11 +931,9 @@ def _internal_init(__self__,
__props__.__dict__["scaling_up_policies"] = scaling_up_policies
__props__.__dict__["scheduled_tasks"] = scheduled_tasks
__props__.__dict__["shutdown_script"] = shutdown_script
- strategy = _utilities.configure(strategy, ElastigroupStrategyArgs, True)
if strategy is None and not opts.urn:
raise TypeError("Missing required property 'strategy'")
__props__.__dict__["strategy"] = strategy
- update_policy = _utilities.configure(update_policy, ElastigroupUpdatePolicyArgs, True)
__props__.__dict__["update_policy"] = update_policy
__props__.__dict__["user_data"] = user_data
super(Elastigroup, __self__).__init__(
diff --git a/sdk/python/pulumi_spotinst/azure/ocean.py b/sdk/python/pulumi_spotinst/azure/ocean.py
index b1fc4164..4310aeaf 100644
--- a/sdk/python/pulumi_spotinst/azure/ocean.py
+++ b/sdk/python/pulumi_spotinst/azure/ocean.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs
from ._inputs import *
@@ -63,133 +63,46 @@ def __init__(__self__, *,
:param pulumi.Input[Sequence[pulumi.Input['OceanVmSizeArgs']]] vm_sizes: The types of virtual machines that may or may not be a part of the Ocean cluster.
:param pulumi.Input[Sequence[pulumi.Input[str]]] zones: An Array holding default Availability Zones, this configures the availability zones the Ocean may launch instances in.
"""
- OceanArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- acd_identifier=acd_identifier,
- aks_name=aks_name,
- aks_resource_group_name=aks_resource_group_name,
- ssh_public_key=ssh_public_key,
- autoscaler=autoscaler,
- controller_cluster_id=controller_cluster_id,
- custom_data=custom_data,
- extensions=extensions,
- health=health,
- images=images,
- load_balancers=load_balancers,
- managed_service_identities=managed_service_identities,
- max_pods=max_pods,
- name=name,
- network=network,
- os_disk=os_disk,
- resource_group_name=resource_group_name,
- strategies=strategies,
- tags=tags,
- user_name=user_name,
- vm_sizes=vm_sizes,
- zones=zones,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- acd_identifier: Optional[pulumi.Input[str]] = None,
- aks_name: Optional[pulumi.Input[str]] = None,
- aks_resource_group_name: Optional[pulumi.Input[str]] = None,
- ssh_public_key: Optional[pulumi.Input[str]] = None,
- autoscaler: Optional[pulumi.Input['OceanAutoscalerArgs']] = None,
- controller_cluster_id: Optional[pulumi.Input[str]] = None,
- custom_data: Optional[pulumi.Input[str]] = None,
- extensions: Optional[pulumi.Input[Sequence[pulumi.Input['OceanExtensionArgs']]]] = None,
- health: Optional[pulumi.Input['OceanHealthArgs']] = None,
- images: Optional[pulumi.Input[Sequence[pulumi.Input['OceanImageArgs']]]] = None,
- load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLoadBalancerArgs']]]] = None,
- managed_service_identities: Optional[pulumi.Input[Sequence[pulumi.Input['OceanManagedServiceIdentityArgs']]]] = None,
- max_pods: Optional[pulumi.Input[int]] = None,
- name: Optional[pulumi.Input[str]] = None,
- network: Optional[pulumi.Input['OceanNetworkArgs']] = None,
- os_disk: Optional[pulumi.Input['OceanOsDiskArgs']] = None,
- resource_group_name: Optional[pulumi.Input[str]] = None,
- strategies: Optional[pulumi.Input[Sequence[pulumi.Input['OceanStrategyArgs']]]] = None,
- tags: Optional[pulumi.Input[Sequence[pulumi.Input['OceanTagArgs']]]] = None,
- user_name: Optional[pulumi.Input[str]] = None,
- vm_sizes: Optional[pulumi.Input[Sequence[pulumi.Input['OceanVmSizeArgs']]]] = None,
- zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if acd_identifier is None and 'acdIdentifier' in kwargs:
- acd_identifier = kwargs['acdIdentifier']
- if acd_identifier is None:
- raise TypeError("Missing 'acd_identifier' argument")
- if aks_name is None and 'aksName' in kwargs:
- aks_name = kwargs['aksName']
- if aks_name is None:
- raise TypeError("Missing 'aks_name' argument")
- if aks_resource_group_name is None and 'aksResourceGroupName' in kwargs:
- aks_resource_group_name = kwargs['aksResourceGroupName']
- if aks_resource_group_name is None:
- raise TypeError("Missing 'aks_resource_group_name' argument")
- if ssh_public_key is None and 'sshPublicKey' in kwargs:
- ssh_public_key = kwargs['sshPublicKey']
- if ssh_public_key is None:
- raise TypeError("Missing 'ssh_public_key' argument")
- if controller_cluster_id is None and 'controllerClusterId' in kwargs:
- controller_cluster_id = kwargs['controllerClusterId']
- if custom_data is None and 'customData' in kwargs:
- custom_data = kwargs['customData']
- if load_balancers is None and 'loadBalancers' in kwargs:
- load_balancers = kwargs['loadBalancers']
- if managed_service_identities is None and 'managedServiceIdentities' in kwargs:
- managed_service_identities = kwargs['managedServiceIdentities']
- if max_pods is None and 'maxPods' in kwargs:
- max_pods = kwargs['maxPods']
- if os_disk is None and 'osDisk' in kwargs:
- os_disk = kwargs['osDisk']
- if resource_group_name is None and 'resourceGroupName' in kwargs:
- resource_group_name = kwargs['resourceGroupName']
- if user_name is None and 'userName' in kwargs:
- user_name = kwargs['userName']
- if vm_sizes is None and 'vmSizes' in kwargs:
- vm_sizes = kwargs['vmSizes']
-
- _setter("acd_identifier", acd_identifier)
- _setter("aks_name", aks_name)
- _setter("aks_resource_group_name", aks_resource_group_name)
- _setter("ssh_public_key", ssh_public_key)
+ pulumi.set(__self__, "acd_identifier", acd_identifier)
+ pulumi.set(__self__, "aks_name", aks_name)
+ pulumi.set(__self__, "aks_resource_group_name", aks_resource_group_name)
+ pulumi.set(__self__, "ssh_public_key", ssh_public_key)
if autoscaler is not None:
- _setter("autoscaler", autoscaler)
+ pulumi.set(__self__, "autoscaler", autoscaler)
if controller_cluster_id is not None:
- _setter("controller_cluster_id", controller_cluster_id)
+ pulumi.set(__self__, "controller_cluster_id", controller_cluster_id)
if custom_data is not None:
- _setter("custom_data", custom_data)
+ pulumi.set(__self__, "custom_data", custom_data)
if extensions is not None:
- _setter("extensions", extensions)
+ pulumi.set(__self__, "extensions", extensions)
if health is not None:
- _setter("health", health)
+ pulumi.set(__self__, "health", health)
if images is not None:
- _setter("images", images)
+ pulumi.set(__self__, "images", images)
if load_balancers is not None:
- _setter("load_balancers", load_balancers)
+ pulumi.set(__self__, "load_balancers", load_balancers)
if managed_service_identities is not None:
- _setter("managed_service_identities", managed_service_identities)
+ pulumi.set(__self__, "managed_service_identities", managed_service_identities)
if max_pods is not None:
- _setter("max_pods", max_pods)
+ pulumi.set(__self__, "max_pods", max_pods)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if network is not None:
- _setter("network", network)
+ pulumi.set(__self__, "network", network)
if os_disk is not None:
- _setter("os_disk", os_disk)
+ pulumi.set(__self__, "os_disk", os_disk)
if resource_group_name is not None:
- _setter("resource_group_name", resource_group_name)
+ pulumi.set(__self__, "resource_group_name", resource_group_name)
if strategies is not None:
- _setter("strategies", strategies)
+ pulumi.set(__self__, "strategies", strategies)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
if user_name is not None:
- _setter("user_name", user_name)
+ pulumi.set(__self__, "user_name", user_name)
if vm_sizes is not None:
- _setter("vm_sizes", vm_sizes)
+ pulumi.set(__self__, "vm_sizes", vm_sizes)
if zones is not None:
- _setter("zones", zones)
+ pulumi.set(__self__, "zones", zones)
@property
@pulumi.getter(name="acdIdentifier")
@@ -506,129 +419,50 @@ def __init__(__self__, *,
:param pulumi.Input[Sequence[pulumi.Input['OceanVmSizeArgs']]] vm_sizes: The types of virtual machines that may or may not be a part of the Ocean cluster.
:param pulumi.Input[Sequence[pulumi.Input[str]]] zones: An Array holding default Availability Zones, this configures the availability zones the Ocean may launch instances in.
"""
- _OceanState._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- acd_identifier=acd_identifier,
- aks_name=aks_name,
- aks_resource_group_name=aks_resource_group_name,
- autoscaler=autoscaler,
- controller_cluster_id=controller_cluster_id,
- custom_data=custom_data,
- extensions=extensions,
- health=health,
- images=images,
- load_balancers=load_balancers,
- managed_service_identities=managed_service_identities,
- max_pods=max_pods,
- name=name,
- network=network,
- os_disk=os_disk,
- resource_group_name=resource_group_name,
- ssh_public_key=ssh_public_key,
- strategies=strategies,
- tags=tags,
- user_name=user_name,
- vm_sizes=vm_sizes,
- zones=zones,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- acd_identifier: Optional[pulumi.Input[str]] = None,
- aks_name: Optional[pulumi.Input[str]] = None,
- aks_resource_group_name: Optional[pulumi.Input[str]] = None,
- autoscaler: Optional[pulumi.Input['OceanAutoscalerArgs']] = None,
- controller_cluster_id: Optional[pulumi.Input[str]] = None,
- custom_data: Optional[pulumi.Input[str]] = None,
- extensions: Optional[pulumi.Input[Sequence[pulumi.Input['OceanExtensionArgs']]]] = None,
- health: Optional[pulumi.Input['OceanHealthArgs']] = None,
- images: Optional[pulumi.Input[Sequence[pulumi.Input['OceanImageArgs']]]] = None,
- load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLoadBalancerArgs']]]] = None,
- managed_service_identities: Optional[pulumi.Input[Sequence[pulumi.Input['OceanManagedServiceIdentityArgs']]]] = None,
- max_pods: Optional[pulumi.Input[int]] = None,
- name: Optional[pulumi.Input[str]] = None,
- network: Optional[pulumi.Input['OceanNetworkArgs']] = None,
- os_disk: Optional[pulumi.Input['OceanOsDiskArgs']] = None,
- resource_group_name: Optional[pulumi.Input[str]] = None,
- ssh_public_key: Optional[pulumi.Input[str]] = None,
- strategies: Optional[pulumi.Input[Sequence[pulumi.Input['OceanStrategyArgs']]]] = None,
- tags: Optional[pulumi.Input[Sequence[pulumi.Input['OceanTagArgs']]]] = None,
- user_name: Optional[pulumi.Input[str]] = None,
- vm_sizes: Optional[pulumi.Input[Sequence[pulumi.Input['OceanVmSizeArgs']]]] = None,
- zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if acd_identifier is None and 'acdIdentifier' in kwargs:
- acd_identifier = kwargs['acdIdentifier']
- if aks_name is None and 'aksName' in kwargs:
- aks_name = kwargs['aksName']
- if aks_resource_group_name is None and 'aksResourceGroupName' in kwargs:
- aks_resource_group_name = kwargs['aksResourceGroupName']
- if controller_cluster_id is None and 'controllerClusterId' in kwargs:
- controller_cluster_id = kwargs['controllerClusterId']
- if custom_data is None and 'customData' in kwargs:
- custom_data = kwargs['customData']
- if load_balancers is None and 'loadBalancers' in kwargs:
- load_balancers = kwargs['loadBalancers']
- if managed_service_identities is None and 'managedServiceIdentities' in kwargs:
- managed_service_identities = kwargs['managedServiceIdentities']
- if max_pods is None and 'maxPods' in kwargs:
- max_pods = kwargs['maxPods']
- if os_disk is None and 'osDisk' in kwargs:
- os_disk = kwargs['osDisk']
- if resource_group_name is None and 'resourceGroupName' in kwargs:
- resource_group_name = kwargs['resourceGroupName']
- if ssh_public_key is None and 'sshPublicKey' in kwargs:
- ssh_public_key = kwargs['sshPublicKey']
- if user_name is None and 'userName' in kwargs:
- user_name = kwargs['userName']
- if vm_sizes is None and 'vmSizes' in kwargs:
- vm_sizes = kwargs['vmSizes']
-
if acd_identifier is not None:
- _setter("acd_identifier", acd_identifier)
+ pulumi.set(__self__, "acd_identifier", acd_identifier)
if aks_name is not None:
- _setter("aks_name", aks_name)
+ pulumi.set(__self__, "aks_name", aks_name)
if aks_resource_group_name is not None:
- _setter("aks_resource_group_name", aks_resource_group_name)
+ pulumi.set(__self__, "aks_resource_group_name", aks_resource_group_name)
if autoscaler is not None:
- _setter("autoscaler", autoscaler)
+ pulumi.set(__self__, "autoscaler", autoscaler)
if controller_cluster_id is not None:
- _setter("controller_cluster_id", controller_cluster_id)
+ pulumi.set(__self__, "controller_cluster_id", controller_cluster_id)
if custom_data is not None:
- _setter("custom_data", custom_data)
+ pulumi.set(__self__, "custom_data", custom_data)
if extensions is not None:
- _setter("extensions", extensions)
+ pulumi.set(__self__, "extensions", extensions)
if health is not None:
- _setter("health", health)
+ pulumi.set(__self__, "health", health)
if images is not None:
- _setter("images", images)
+ pulumi.set(__self__, "images", images)
if load_balancers is not None:
- _setter("load_balancers", load_balancers)
+ pulumi.set(__self__, "load_balancers", load_balancers)
if managed_service_identities is not None:
- _setter("managed_service_identities", managed_service_identities)
+ pulumi.set(__self__, "managed_service_identities", managed_service_identities)
if max_pods is not None:
- _setter("max_pods", max_pods)
+ pulumi.set(__self__, "max_pods", max_pods)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if network is not None:
- _setter("network", network)
+ pulumi.set(__self__, "network", network)
if os_disk is not None:
- _setter("os_disk", os_disk)
+ pulumi.set(__self__, "os_disk", os_disk)
if resource_group_name is not None:
- _setter("resource_group_name", resource_group_name)
+ pulumi.set(__self__, "resource_group_name", resource_group_name)
if ssh_public_key is not None:
- _setter("ssh_public_key", ssh_public_key)
+ pulumi.set(__self__, "ssh_public_key", ssh_public_key)
if strategies is not None:
- _setter("strategies", strategies)
+ pulumi.set(__self__, "strategies", strategies)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
if user_name is not None:
- _setter("user_name", user_name)
+ pulumi.set(__self__, "user_name", user_name)
if vm_sizes is not None:
- _setter("vm_sizes", vm_sizes)
+ pulumi.set(__self__, "vm_sizes", vm_sizes)
if zones is not None:
- _setter("zones", zones)
+ pulumi.set(__self__, "zones", zones)
@property
@pulumi.getter(name="acdIdentifier")
@@ -994,10 +828,6 @@ def __init__(__self__, resource_name: str, *args, **kwargs):
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
- kwargs = kwargs or {}
- def _setter(key, value):
- kwargs[key] = value
- OceanArgs._configure(_setter, **kwargs)
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
@@ -1043,21 +873,17 @@ def _internal_init(__self__,
if aks_resource_group_name is None and not opts.urn:
raise TypeError("Missing required property 'aks_resource_group_name'")
__props__.__dict__["aks_resource_group_name"] = aks_resource_group_name
- autoscaler = _utilities.configure(autoscaler, OceanAutoscalerArgs, True)
__props__.__dict__["autoscaler"] = autoscaler
__props__.__dict__["controller_cluster_id"] = controller_cluster_id
__props__.__dict__["custom_data"] = custom_data
__props__.__dict__["extensions"] = extensions
- health = _utilities.configure(health, OceanHealthArgs, True)
__props__.__dict__["health"] = health
__props__.__dict__["images"] = images
__props__.__dict__["load_balancers"] = load_balancers
__props__.__dict__["managed_service_identities"] = managed_service_identities
__props__.__dict__["max_pods"] = max_pods
__props__.__dict__["name"] = name
- network = _utilities.configure(network, OceanNetworkArgs, True)
__props__.__dict__["network"] = network
- os_disk = _utilities.configure(os_disk, OceanOsDiskArgs, True)
__props__.__dict__["os_disk"] = os_disk
__props__.__dict__["resource_group_name"] = resource_group_name
if ssh_public_key is None and not opts.urn:
diff --git a/sdk/python/pulumi_spotinst/azure/ocean_np.py b/sdk/python/pulumi_spotinst/azure/ocean_np.py
index ae885e50..034898eb 100644
--- a/sdk/python/pulumi_spotinst/azure/ocean_np.py
+++ b/sdk/python/pulumi_spotinst/azure/ocean_np.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs
from ._inputs import *
@@ -47,170 +47,57 @@ def __init__(__self__, *,
"""
The set of arguments for constructing a OceanNp resource.
"""
- OceanNpArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- aks_cluster_name=aks_cluster_name,
- aks_infrastructure_resource_group_name=aks_infrastructure_resource_group_name,
- aks_region=aks_region,
- aks_resource_group_name=aks_resource_group_name,
- availability_zones=availability_zones,
- autoscaler=autoscaler,
- controller_cluster_id=controller_cluster_id,
- enable_node_public_ip=enable_node_public_ip,
- fallback_to_ondemand=fallback_to_ondemand,
- filters=filters,
- headrooms=headrooms,
- health=health,
- kubernetes_version=kubernetes_version,
- labels=labels,
- max_count=max_count,
- max_pods_per_node=max_pods_per_node,
- min_count=min_count,
- name=name,
- os_disk_size_gb=os_disk_size_gb,
- os_disk_type=os_disk_type,
- os_sku=os_sku,
- os_type=os_type,
- pod_subnet_ids=pod_subnet_ids,
- scheduling=scheduling,
- spot_percentage=spot_percentage,
- tags=tags,
- taints=taints,
- vnet_subnet_ids=vnet_subnet_ids,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- aks_cluster_name: Optional[pulumi.Input[str]] = None,
- aks_infrastructure_resource_group_name: Optional[pulumi.Input[str]] = None,
- aks_region: Optional[pulumi.Input[str]] = None,
- aks_resource_group_name: Optional[pulumi.Input[str]] = None,
- availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- autoscaler: Optional[pulumi.Input['OceanNpAutoscalerArgs']] = None,
- controller_cluster_id: Optional[pulumi.Input[str]] = None,
- enable_node_public_ip: Optional[pulumi.Input[bool]] = None,
- fallback_to_ondemand: Optional[pulumi.Input[bool]] = None,
- filters: Optional[pulumi.Input['OceanNpFiltersArgs']] = None,
- headrooms: Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpHeadroomArgs']]]] = None,
- health: Optional[pulumi.Input['OceanNpHealthArgs']] = None,
- kubernetes_version: Optional[pulumi.Input[str]] = None,
- labels: Optional[pulumi.Input[Mapping[str, Any]]] = None,
- max_count: Optional[pulumi.Input[int]] = None,
- max_pods_per_node: Optional[pulumi.Input[int]] = None,
- min_count: Optional[pulumi.Input[int]] = None,
- name: Optional[pulumi.Input[str]] = None,
- os_disk_size_gb: Optional[pulumi.Input[int]] = None,
- os_disk_type: Optional[pulumi.Input[str]] = None,
- os_sku: Optional[pulumi.Input[str]] = None,
- os_type: Optional[pulumi.Input[str]] = None,
- pod_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- scheduling: Optional[pulumi.Input['OceanNpSchedulingArgs']] = None,
- spot_percentage: Optional[pulumi.Input[int]] = None,
- tags: Optional[pulumi.Input[Mapping[str, Any]]] = None,
- taints: Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpTaintArgs']]]] = None,
- vnet_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if aks_cluster_name is None and 'aksClusterName' in kwargs:
- aks_cluster_name = kwargs['aksClusterName']
- if aks_cluster_name is None:
- raise TypeError("Missing 'aks_cluster_name' argument")
- if aks_infrastructure_resource_group_name is None and 'aksInfrastructureResourceGroupName' in kwargs:
- aks_infrastructure_resource_group_name = kwargs['aksInfrastructureResourceGroupName']
- if aks_infrastructure_resource_group_name is None:
- raise TypeError("Missing 'aks_infrastructure_resource_group_name' argument")
- if aks_region is None and 'aksRegion' in kwargs:
- aks_region = kwargs['aksRegion']
- if aks_region is None:
- raise TypeError("Missing 'aks_region' argument")
- if aks_resource_group_name is None and 'aksResourceGroupName' in kwargs:
- aks_resource_group_name = kwargs['aksResourceGroupName']
- if aks_resource_group_name is None:
- raise TypeError("Missing 'aks_resource_group_name' argument")
- if availability_zones is None and 'availabilityZones' in kwargs:
- availability_zones = kwargs['availabilityZones']
- if availability_zones is None:
- raise TypeError("Missing 'availability_zones' argument")
- if controller_cluster_id is None and 'controllerClusterId' in kwargs:
- controller_cluster_id = kwargs['controllerClusterId']
- if enable_node_public_ip is None and 'enableNodePublicIp' in kwargs:
- enable_node_public_ip = kwargs['enableNodePublicIp']
- if fallback_to_ondemand is None and 'fallbackToOndemand' in kwargs:
- fallback_to_ondemand = kwargs['fallbackToOndemand']
- if kubernetes_version is None and 'kubernetesVersion' in kwargs:
- kubernetes_version = kwargs['kubernetesVersion']
- if max_count is None and 'maxCount' in kwargs:
- max_count = kwargs['maxCount']
- if max_pods_per_node is None and 'maxPodsPerNode' in kwargs:
- max_pods_per_node = kwargs['maxPodsPerNode']
- if min_count is None and 'minCount' in kwargs:
- min_count = kwargs['minCount']
- if os_disk_size_gb is None and 'osDiskSizeGb' in kwargs:
- os_disk_size_gb = kwargs['osDiskSizeGb']
- if os_disk_type is None and 'osDiskType' in kwargs:
- os_disk_type = kwargs['osDiskType']
- if os_sku is None and 'osSku' in kwargs:
- os_sku = kwargs['osSku']
- if os_type is None and 'osType' in kwargs:
- os_type = kwargs['osType']
- if pod_subnet_ids is None and 'podSubnetIds' in kwargs:
- pod_subnet_ids = kwargs['podSubnetIds']
- if spot_percentage is None and 'spotPercentage' in kwargs:
- spot_percentage = kwargs['spotPercentage']
- if vnet_subnet_ids is None and 'vnetSubnetIds' in kwargs:
- vnet_subnet_ids = kwargs['vnetSubnetIds']
-
- _setter("aks_cluster_name", aks_cluster_name)
- _setter("aks_infrastructure_resource_group_name", aks_infrastructure_resource_group_name)
- _setter("aks_region", aks_region)
- _setter("aks_resource_group_name", aks_resource_group_name)
- _setter("availability_zones", availability_zones)
+ pulumi.set(__self__, "aks_cluster_name", aks_cluster_name)
+ pulumi.set(__self__, "aks_infrastructure_resource_group_name", aks_infrastructure_resource_group_name)
+ pulumi.set(__self__, "aks_region", aks_region)
+ pulumi.set(__self__, "aks_resource_group_name", aks_resource_group_name)
+ pulumi.set(__self__, "availability_zones", availability_zones)
if autoscaler is not None:
- _setter("autoscaler", autoscaler)
+ pulumi.set(__self__, "autoscaler", autoscaler)
if controller_cluster_id is not None:
- _setter("controller_cluster_id", controller_cluster_id)
+ pulumi.set(__self__, "controller_cluster_id", controller_cluster_id)
if enable_node_public_ip is not None:
- _setter("enable_node_public_ip", enable_node_public_ip)
+ pulumi.set(__self__, "enable_node_public_ip", enable_node_public_ip)
if fallback_to_ondemand is not None:
- _setter("fallback_to_ondemand", fallback_to_ondemand)
+ pulumi.set(__self__, "fallback_to_ondemand", fallback_to_ondemand)
if filters is not None:
- _setter("filters", filters)
+ pulumi.set(__self__, "filters", filters)
if headrooms is not None:
- _setter("headrooms", headrooms)
+ pulumi.set(__self__, "headrooms", headrooms)
if health is not None:
- _setter("health", health)
+ pulumi.set(__self__, "health", health)
if kubernetes_version is not None:
- _setter("kubernetes_version", kubernetes_version)
+ pulumi.set(__self__, "kubernetes_version", kubernetes_version)
if labels is not None:
- _setter("labels", labels)
+ pulumi.set(__self__, "labels", labels)
if max_count is not None:
- _setter("max_count", max_count)
+ pulumi.set(__self__, "max_count", max_count)
if max_pods_per_node is not None:
- _setter("max_pods_per_node", max_pods_per_node)
+ pulumi.set(__self__, "max_pods_per_node", max_pods_per_node)
if min_count is not None:
- _setter("min_count", min_count)
+ pulumi.set(__self__, "min_count", min_count)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if os_disk_size_gb is not None:
- _setter("os_disk_size_gb", os_disk_size_gb)
+ pulumi.set(__self__, "os_disk_size_gb", os_disk_size_gb)
if os_disk_type is not None:
- _setter("os_disk_type", os_disk_type)
+ pulumi.set(__self__, "os_disk_type", os_disk_type)
if os_sku is not None:
- _setter("os_sku", os_sku)
+ pulumi.set(__self__, "os_sku", os_sku)
if os_type is not None:
- _setter("os_type", os_type)
+ pulumi.set(__self__, "os_type", os_type)
if pod_subnet_ids is not None:
- _setter("pod_subnet_ids", pod_subnet_ids)
+ pulumi.set(__self__, "pod_subnet_ids", pod_subnet_ids)
if scheduling is not None:
- _setter("scheduling", scheduling)
+ pulumi.set(__self__, "scheduling", scheduling)
if spot_percentage is not None:
- _setter("spot_percentage", spot_percentage)
+ pulumi.set(__self__, "spot_percentage", spot_percentage)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
if taints is not None:
- _setter("taints", taints)
+ pulumi.set(__self__, "taints", taints)
if vnet_subnet_ids is not None:
- _setter("vnet_subnet_ids", vnet_subnet_ids)
+ pulumi.set(__self__, "vnet_subnet_ids", vnet_subnet_ids)
@property
@pulumi.getter(name="aksClusterName")
@@ -499,165 +386,62 @@ def __init__(__self__, *,
"""
Input properties used for looking up and filtering OceanNp resources.
"""
- _OceanNpState._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- aks_cluster_name=aks_cluster_name,
- aks_infrastructure_resource_group_name=aks_infrastructure_resource_group_name,
- aks_region=aks_region,
- aks_resource_group_name=aks_resource_group_name,
- autoscaler=autoscaler,
- availability_zones=availability_zones,
- controller_cluster_id=controller_cluster_id,
- enable_node_public_ip=enable_node_public_ip,
- fallback_to_ondemand=fallback_to_ondemand,
- filters=filters,
- headrooms=headrooms,
- health=health,
- kubernetes_version=kubernetes_version,
- labels=labels,
- max_count=max_count,
- max_pods_per_node=max_pods_per_node,
- min_count=min_count,
- name=name,
- os_disk_size_gb=os_disk_size_gb,
- os_disk_type=os_disk_type,
- os_sku=os_sku,
- os_type=os_type,
- pod_subnet_ids=pod_subnet_ids,
- scheduling=scheduling,
- spot_percentage=spot_percentage,
- tags=tags,
- taints=taints,
- vnet_subnet_ids=vnet_subnet_ids,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- aks_cluster_name: Optional[pulumi.Input[str]] = None,
- aks_infrastructure_resource_group_name: Optional[pulumi.Input[str]] = None,
- aks_region: Optional[pulumi.Input[str]] = None,
- aks_resource_group_name: Optional[pulumi.Input[str]] = None,
- autoscaler: Optional[pulumi.Input['OceanNpAutoscalerArgs']] = None,
- availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- controller_cluster_id: Optional[pulumi.Input[str]] = None,
- enable_node_public_ip: Optional[pulumi.Input[bool]] = None,
- fallback_to_ondemand: Optional[pulumi.Input[bool]] = None,
- filters: Optional[pulumi.Input['OceanNpFiltersArgs']] = None,
- headrooms: Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpHeadroomArgs']]]] = None,
- health: Optional[pulumi.Input['OceanNpHealthArgs']] = None,
- kubernetes_version: Optional[pulumi.Input[str]] = None,
- labels: Optional[pulumi.Input[Mapping[str, Any]]] = None,
- max_count: Optional[pulumi.Input[int]] = None,
- max_pods_per_node: Optional[pulumi.Input[int]] = None,
- min_count: Optional[pulumi.Input[int]] = None,
- name: Optional[pulumi.Input[str]] = None,
- os_disk_size_gb: Optional[pulumi.Input[int]] = None,
- os_disk_type: Optional[pulumi.Input[str]] = None,
- os_sku: Optional[pulumi.Input[str]] = None,
- os_type: Optional[pulumi.Input[str]] = None,
- pod_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- scheduling: Optional[pulumi.Input['OceanNpSchedulingArgs']] = None,
- spot_percentage: Optional[pulumi.Input[int]] = None,
- tags: Optional[pulumi.Input[Mapping[str, Any]]] = None,
- taints: Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpTaintArgs']]]] = None,
- vnet_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if aks_cluster_name is None and 'aksClusterName' in kwargs:
- aks_cluster_name = kwargs['aksClusterName']
- if aks_infrastructure_resource_group_name is None and 'aksInfrastructureResourceGroupName' in kwargs:
- aks_infrastructure_resource_group_name = kwargs['aksInfrastructureResourceGroupName']
- if aks_region is None and 'aksRegion' in kwargs:
- aks_region = kwargs['aksRegion']
- if aks_resource_group_name is None and 'aksResourceGroupName' in kwargs:
- aks_resource_group_name = kwargs['aksResourceGroupName']
- if availability_zones is None and 'availabilityZones' in kwargs:
- availability_zones = kwargs['availabilityZones']
- if controller_cluster_id is None and 'controllerClusterId' in kwargs:
- controller_cluster_id = kwargs['controllerClusterId']
- if enable_node_public_ip is None and 'enableNodePublicIp' in kwargs:
- enable_node_public_ip = kwargs['enableNodePublicIp']
- if fallback_to_ondemand is None and 'fallbackToOndemand' in kwargs:
- fallback_to_ondemand = kwargs['fallbackToOndemand']
- if kubernetes_version is None and 'kubernetesVersion' in kwargs:
- kubernetes_version = kwargs['kubernetesVersion']
- if max_count is None and 'maxCount' in kwargs:
- max_count = kwargs['maxCount']
- if max_pods_per_node is None and 'maxPodsPerNode' in kwargs:
- max_pods_per_node = kwargs['maxPodsPerNode']
- if min_count is None and 'minCount' in kwargs:
- min_count = kwargs['minCount']
- if os_disk_size_gb is None and 'osDiskSizeGb' in kwargs:
- os_disk_size_gb = kwargs['osDiskSizeGb']
- if os_disk_type is None and 'osDiskType' in kwargs:
- os_disk_type = kwargs['osDiskType']
- if os_sku is None and 'osSku' in kwargs:
- os_sku = kwargs['osSku']
- if os_type is None and 'osType' in kwargs:
- os_type = kwargs['osType']
- if pod_subnet_ids is None and 'podSubnetIds' in kwargs:
- pod_subnet_ids = kwargs['podSubnetIds']
- if spot_percentage is None and 'spotPercentage' in kwargs:
- spot_percentage = kwargs['spotPercentage']
- if vnet_subnet_ids is None and 'vnetSubnetIds' in kwargs:
- vnet_subnet_ids = kwargs['vnetSubnetIds']
-
if aks_cluster_name is not None:
- _setter("aks_cluster_name", aks_cluster_name)
+ pulumi.set(__self__, "aks_cluster_name", aks_cluster_name)
if aks_infrastructure_resource_group_name is not None:
- _setter("aks_infrastructure_resource_group_name", aks_infrastructure_resource_group_name)
+ pulumi.set(__self__, "aks_infrastructure_resource_group_name", aks_infrastructure_resource_group_name)
if aks_region is not None:
- _setter("aks_region", aks_region)
+ pulumi.set(__self__, "aks_region", aks_region)
if aks_resource_group_name is not None:
- _setter("aks_resource_group_name", aks_resource_group_name)
+ pulumi.set(__self__, "aks_resource_group_name", aks_resource_group_name)
if autoscaler is not None:
- _setter("autoscaler", autoscaler)
+ pulumi.set(__self__, "autoscaler", autoscaler)
if availability_zones is not None:
- _setter("availability_zones", availability_zones)
+ pulumi.set(__self__, "availability_zones", availability_zones)
if controller_cluster_id is not None:
- _setter("controller_cluster_id", controller_cluster_id)
+ pulumi.set(__self__, "controller_cluster_id", controller_cluster_id)
if enable_node_public_ip is not None:
- _setter("enable_node_public_ip", enable_node_public_ip)
+ pulumi.set(__self__, "enable_node_public_ip", enable_node_public_ip)
if fallback_to_ondemand is not None:
- _setter("fallback_to_ondemand", fallback_to_ondemand)
+ pulumi.set(__self__, "fallback_to_ondemand", fallback_to_ondemand)
if filters is not None:
- _setter("filters", filters)
+ pulumi.set(__self__, "filters", filters)
if headrooms is not None:
- _setter("headrooms", headrooms)
+ pulumi.set(__self__, "headrooms", headrooms)
if health is not None:
- _setter("health", health)
+ pulumi.set(__self__, "health", health)
if kubernetes_version is not None:
- _setter("kubernetes_version", kubernetes_version)
+ pulumi.set(__self__, "kubernetes_version", kubernetes_version)
if labels is not None:
- _setter("labels", labels)
+ pulumi.set(__self__, "labels", labels)
if max_count is not None:
- _setter("max_count", max_count)
+ pulumi.set(__self__, "max_count", max_count)
if max_pods_per_node is not None:
- _setter("max_pods_per_node", max_pods_per_node)
+ pulumi.set(__self__, "max_pods_per_node", max_pods_per_node)
if min_count is not None:
- _setter("min_count", min_count)
+ pulumi.set(__self__, "min_count", min_count)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if os_disk_size_gb is not None:
- _setter("os_disk_size_gb", os_disk_size_gb)
+ pulumi.set(__self__, "os_disk_size_gb", os_disk_size_gb)
if os_disk_type is not None:
- _setter("os_disk_type", os_disk_type)
+ pulumi.set(__self__, "os_disk_type", os_disk_type)
if os_sku is not None:
- _setter("os_sku", os_sku)
+ pulumi.set(__self__, "os_sku", os_sku)
if os_type is not None:
- _setter("os_type", os_type)
+ pulumi.set(__self__, "os_type", os_type)
if pod_subnet_ids is not None:
- _setter("pod_subnet_ids", pod_subnet_ids)
+ pulumi.set(__self__, "pod_subnet_ids", pod_subnet_ids)
if scheduling is not None:
- _setter("scheduling", scheduling)
+ pulumi.set(__self__, "scheduling", scheduling)
if spot_percentage is not None:
- _setter("spot_percentage", spot_percentage)
+ pulumi.set(__self__, "spot_percentage", spot_percentage)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
if taints is not None:
- _setter("taints", taints)
+ pulumi.set(__self__, "taints", taints)
if vnet_subnet_ids is not None:
- _setter("vnet_subnet_ids", vnet_subnet_ids)
+ pulumi.set(__self__, "vnet_subnet_ids", vnet_subnet_ids)
@property
@pulumi.getter(name="aksClusterName")
@@ -969,10 +753,6 @@ def __init__(__self__, resource_name: str, *args, **kwargs):
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
- kwargs = kwargs or {}
- def _setter(key, value):
- kwargs[key] = value
- OceanNpArgs._configure(_setter, **kwargs)
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
@@ -1027,7 +807,6 @@ def _internal_init(__self__,
if aks_resource_group_name is None and not opts.urn:
raise TypeError("Missing required property 'aks_resource_group_name'")
__props__.__dict__["aks_resource_group_name"] = aks_resource_group_name
- autoscaler = _utilities.configure(autoscaler, OceanNpAutoscalerArgs, True)
__props__.__dict__["autoscaler"] = autoscaler
if availability_zones is None and not opts.urn:
raise TypeError("Missing required property 'availability_zones'")
@@ -1035,10 +814,8 @@ def _internal_init(__self__,
__props__.__dict__["controller_cluster_id"] = controller_cluster_id
__props__.__dict__["enable_node_public_ip"] = enable_node_public_ip
__props__.__dict__["fallback_to_ondemand"] = fallback_to_ondemand
- filters = _utilities.configure(filters, OceanNpFiltersArgs, True)
__props__.__dict__["filters"] = filters
__props__.__dict__["headrooms"] = headrooms
- health = _utilities.configure(health, OceanNpHealthArgs, True)
__props__.__dict__["health"] = health
__props__.__dict__["kubernetes_version"] = kubernetes_version
__props__.__dict__["labels"] = labels
@@ -1051,7 +828,6 @@ def _internal_init(__self__,
__props__.__dict__["os_sku"] = os_sku
__props__.__dict__["os_type"] = os_type
__props__.__dict__["pod_subnet_ids"] = pod_subnet_ids
- scheduling = _utilities.configure(scheduling, OceanNpSchedulingArgs, True)
__props__.__dict__["scheduling"] = scheduling
__props__.__dict__["spot_percentage"] = spot_percentage
__props__.__dict__["tags"] = tags
diff --git a/sdk/python/pulumi_spotinst/azure/ocean_np_virtual_node_group.py b/sdk/python/pulumi_spotinst/azure/ocean_np_virtual_node_group.py
index e1a3572a..0ba7a67b 100644
--- a/sdk/python/pulumi_spotinst/azure/ocean_np_virtual_node_group.py
+++ b/sdk/python/pulumi_spotinst/azure/ocean_np_virtual_node_group.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs
from ._inputs import *
@@ -40,130 +40,47 @@ def __init__(__self__, *,
"""
The set of arguments for constructing a OceanNpVirtualNodeGroup resource.
"""
- OceanNpVirtualNodeGroupArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- ocean_id=ocean_id,
- availability_zones=availability_zones,
- enable_node_public_ip=enable_node_public_ip,
- fallback_to_ondemand=fallback_to_ondemand,
- filters=filters,
- headrooms=headrooms,
- kubernetes_version=kubernetes_version,
- labels=labels,
- max_count=max_count,
- max_pods_per_node=max_pods_per_node,
- min_count=min_count,
- name=name,
- os_disk_size_gb=os_disk_size_gb,
- os_disk_type=os_disk_type,
- os_sku=os_sku,
- os_type=os_type,
- pod_subnet_ids=pod_subnet_ids,
- spot_percentage=spot_percentage,
- tags=tags,
- taints=taints,
- vnet_subnet_ids=vnet_subnet_ids,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- ocean_id: Optional[pulumi.Input[str]] = None,
- availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- enable_node_public_ip: Optional[pulumi.Input[bool]] = None,
- fallback_to_ondemand: Optional[pulumi.Input[bool]] = None,
- filters: Optional[pulumi.Input['OceanNpVirtualNodeGroupFiltersArgs']] = None,
- headrooms: Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpVirtualNodeGroupHeadroomArgs']]]] = None,
- kubernetes_version: Optional[pulumi.Input[str]] = None,
- labels: Optional[pulumi.Input[Mapping[str, Any]]] = None,
- max_count: Optional[pulumi.Input[int]] = None,
- max_pods_per_node: Optional[pulumi.Input[int]] = None,
- min_count: Optional[pulumi.Input[int]] = None,
- name: Optional[pulumi.Input[str]] = None,
- os_disk_size_gb: Optional[pulumi.Input[int]] = None,
- os_disk_type: Optional[pulumi.Input[str]] = None,
- os_sku: Optional[pulumi.Input[str]] = None,
- os_type: Optional[pulumi.Input[str]] = None,
- pod_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- spot_percentage: Optional[pulumi.Input[int]] = None,
- tags: Optional[pulumi.Input[Mapping[str, Any]]] = None,
- taints: Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpVirtualNodeGroupTaintArgs']]]] = None,
- vnet_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if ocean_id is None and 'oceanId' in kwargs:
- ocean_id = kwargs['oceanId']
- if ocean_id is None:
- raise TypeError("Missing 'ocean_id' argument")
- if availability_zones is None and 'availabilityZones' in kwargs:
- availability_zones = kwargs['availabilityZones']
- if enable_node_public_ip is None and 'enableNodePublicIp' in kwargs:
- enable_node_public_ip = kwargs['enableNodePublicIp']
- if fallback_to_ondemand is None and 'fallbackToOndemand' in kwargs:
- fallback_to_ondemand = kwargs['fallbackToOndemand']
- if kubernetes_version is None and 'kubernetesVersion' in kwargs:
- kubernetes_version = kwargs['kubernetesVersion']
- if max_count is None and 'maxCount' in kwargs:
- max_count = kwargs['maxCount']
- if max_pods_per_node is None and 'maxPodsPerNode' in kwargs:
- max_pods_per_node = kwargs['maxPodsPerNode']
- if min_count is None and 'minCount' in kwargs:
- min_count = kwargs['minCount']
- if os_disk_size_gb is None and 'osDiskSizeGb' in kwargs:
- os_disk_size_gb = kwargs['osDiskSizeGb']
- if os_disk_type is None and 'osDiskType' in kwargs:
- os_disk_type = kwargs['osDiskType']
- if os_sku is None and 'osSku' in kwargs:
- os_sku = kwargs['osSku']
- if os_type is None and 'osType' in kwargs:
- os_type = kwargs['osType']
- if pod_subnet_ids is None and 'podSubnetIds' in kwargs:
- pod_subnet_ids = kwargs['podSubnetIds']
- if spot_percentage is None and 'spotPercentage' in kwargs:
- spot_percentage = kwargs['spotPercentage']
- if vnet_subnet_ids is None and 'vnetSubnetIds' in kwargs:
- vnet_subnet_ids = kwargs['vnetSubnetIds']
-
- _setter("ocean_id", ocean_id)
+ pulumi.set(__self__, "ocean_id", ocean_id)
if availability_zones is not None:
- _setter("availability_zones", availability_zones)
+ pulumi.set(__self__, "availability_zones", availability_zones)
if enable_node_public_ip is not None:
- _setter("enable_node_public_ip", enable_node_public_ip)
+ pulumi.set(__self__, "enable_node_public_ip", enable_node_public_ip)
if fallback_to_ondemand is not None:
- _setter("fallback_to_ondemand", fallback_to_ondemand)
+ pulumi.set(__self__, "fallback_to_ondemand", fallback_to_ondemand)
if filters is not None:
- _setter("filters", filters)
+ pulumi.set(__self__, "filters", filters)
if headrooms is not None:
- _setter("headrooms", headrooms)
+ pulumi.set(__self__, "headrooms", headrooms)
if kubernetes_version is not None:
- _setter("kubernetes_version", kubernetes_version)
+ pulumi.set(__self__, "kubernetes_version", kubernetes_version)
if labels is not None:
- _setter("labels", labels)
+ pulumi.set(__self__, "labels", labels)
if max_count is not None:
- _setter("max_count", max_count)
+ pulumi.set(__self__, "max_count", max_count)
if max_pods_per_node is not None:
- _setter("max_pods_per_node", max_pods_per_node)
+ pulumi.set(__self__, "max_pods_per_node", max_pods_per_node)
if min_count is not None:
- _setter("min_count", min_count)
+ pulumi.set(__self__, "min_count", min_count)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if os_disk_size_gb is not None:
- _setter("os_disk_size_gb", os_disk_size_gb)
+ pulumi.set(__self__, "os_disk_size_gb", os_disk_size_gb)
if os_disk_type is not None:
- _setter("os_disk_type", os_disk_type)
+ pulumi.set(__self__, "os_disk_type", os_disk_type)
if os_sku is not None:
- _setter("os_sku", os_sku)
+ pulumi.set(__self__, "os_sku", os_sku)
if os_type is not None:
- _setter("os_type", os_type)
+ pulumi.set(__self__, "os_type", os_type)
if pod_subnet_ids is not None:
- _setter("pod_subnet_ids", pod_subnet_ids)
+ pulumi.set(__self__, "pod_subnet_ids", pod_subnet_ids)
if spot_percentage is not None:
- _setter("spot_percentage", spot_percentage)
+ pulumi.set(__self__, "spot_percentage", spot_percentage)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
if taints is not None:
- _setter("taints", taints)
+ pulumi.set(__self__, "taints", taints)
if vnet_subnet_ids is not None:
- _setter("vnet_subnet_ids", vnet_subnet_ids)
+ pulumi.set(__self__, "vnet_subnet_ids", vnet_subnet_ids)
@property
@pulumi.getter(name="oceanId")
@@ -382,129 +299,48 @@ def __init__(__self__, *,
"""
Input properties used for looking up and filtering OceanNpVirtualNodeGroup resources.
"""
- _OceanNpVirtualNodeGroupState._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- availability_zones=availability_zones,
- enable_node_public_ip=enable_node_public_ip,
- fallback_to_ondemand=fallback_to_ondemand,
- filters=filters,
- headrooms=headrooms,
- kubernetes_version=kubernetes_version,
- labels=labels,
- max_count=max_count,
- max_pods_per_node=max_pods_per_node,
- min_count=min_count,
- name=name,
- ocean_id=ocean_id,
- os_disk_size_gb=os_disk_size_gb,
- os_disk_type=os_disk_type,
- os_sku=os_sku,
- os_type=os_type,
- pod_subnet_ids=pod_subnet_ids,
- spot_percentage=spot_percentage,
- tags=tags,
- taints=taints,
- vnet_subnet_ids=vnet_subnet_ids,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- enable_node_public_ip: Optional[pulumi.Input[bool]] = None,
- fallback_to_ondemand: Optional[pulumi.Input[bool]] = None,
- filters: Optional[pulumi.Input['OceanNpVirtualNodeGroupFiltersArgs']] = None,
- headrooms: Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpVirtualNodeGroupHeadroomArgs']]]] = None,
- kubernetes_version: Optional[pulumi.Input[str]] = None,
- labels: Optional[pulumi.Input[Mapping[str, Any]]] = None,
- max_count: Optional[pulumi.Input[int]] = None,
- max_pods_per_node: Optional[pulumi.Input[int]] = None,
- min_count: Optional[pulumi.Input[int]] = None,
- name: Optional[pulumi.Input[str]] = None,
- ocean_id: Optional[pulumi.Input[str]] = None,
- os_disk_size_gb: Optional[pulumi.Input[int]] = None,
- os_disk_type: Optional[pulumi.Input[str]] = None,
- os_sku: Optional[pulumi.Input[str]] = None,
- os_type: Optional[pulumi.Input[str]] = None,
- pod_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- spot_percentage: Optional[pulumi.Input[int]] = None,
- tags: Optional[pulumi.Input[Mapping[str, Any]]] = None,
- taints: Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpVirtualNodeGroupTaintArgs']]]] = None,
- vnet_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if availability_zones is None and 'availabilityZones' in kwargs:
- availability_zones = kwargs['availabilityZones']
- if enable_node_public_ip is None and 'enableNodePublicIp' in kwargs:
- enable_node_public_ip = kwargs['enableNodePublicIp']
- if fallback_to_ondemand is None and 'fallbackToOndemand' in kwargs:
- fallback_to_ondemand = kwargs['fallbackToOndemand']
- if kubernetes_version is None and 'kubernetesVersion' in kwargs:
- kubernetes_version = kwargs['kubernetesVersion']
- if max_count is None and 'maxCount' in kwargs:
- max_count = kwargs['maxCount']
- if max_pods_per_node is None and 'maxPodsPerNode' in kwargs:
- max_pods_per_node = kwargs['maxPodsPerNode']
- if min_count is None and 'minCount' in kwargs:
- min_count = kwargs['minCount']
- if ocean_id is None and 'oceanId' in kwargs:
- ocean_id = kwargs['oceanId']
- if os_disk_size_gb is None and 'osDiskSizeGb' in kwargs:
- os_disk_size_gb = kwargs['osDiskSizeGb']
- if os_disk_type is None and 'osDiskType' in kwargs:
- os_disk_type = kwargs['osDiskType']
- if os_sku is None and 'osSku' in kwargs:
- os_sku = kwargs['osSku']
- if os_type is None and 'osType' in kwargs:
- os_type = kwargs['osType']
- if pod_subnet_ids is None and 'podSubnetIds' in kwargs:
- pod_subnet_ids = kwargs['podSubnetIds']
- if spot_percentage is None and 'spotPercentage' in kwargs:
- spot_percentage = kwargs['spotPercentage']
- if vnet_subnet_ids is None and 'vnetSubnetIds' in kwargs:
- vnet_subnet_ids = kwargs['vnetSubnetIds']
-
if availability_zones is not None:
- _setter("availability_zones", availability_zones)
+ pulumi.set(__self__, "availability_zones", availability_zones)
if enable_node_public_ip is not None:
- _setter("enable_node_public_ip", enable_node_public_ip)
+ pulumi.set(__self__, "enable_node_public_ip", enable_node_public_ip)
if fallback_to_ondemand is not None:
- _setter("fallback_to_ondemand", fallback_to_ondemand)
+ pulumi.set(__self__, "fallback_to_ondemand", fallback_to_ondemand)
if filters is not None:
- _setter("filters", filters)
+ pulumi.set(__self__, "filters", filters)
if headrooms is not None:
- _setter("headrooms", headrooms)
+ pulumi.set(__self__, "headrooms", headrooms)
if kubernetes_version is not None:
- _setter("kubernetes_version", kubernetes_version)
+ pulumi.set(__self__, "kubernetes_version", kubernetes_version)
if labels is not None:
- _setter("labels", labels)
+ pulumi.set(__self__, "labels", labels)
if max_count is not None:
- _setter("max_count", max_count)
+ pulumi.set(__self__, "max_count", max_count)
if max_pods_per_node is not None:
- _setter("max_pods_per_node", max_pods_per_node)
+ pulumi.set(__self__, "max_pods_per_node", max_pods_per_node)
if min_count is not None:
- _setter("min_count", min_count)
+ pulumi.set(__self__, "min_count", min_count)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if ocean_id is not None:
- _setter("ocean_id", ocean_id)
+ pulumi.set(__self__, "ocean_id", ocean_id)
if os_disk_size_gb is not None:
- _setter("os_disk_size_gb", os_disk_size_gb)
+ pulumi.set(__self__, "os_disk_size_gb", os_disk_size_gb)
if os_disk_type is not None:
- _setter("os_disk_type", os_disk_type)
+ pulumi.set(__self__, "os_disk_type", os_disk_type)
if os_sku is not None:
- _setter("os_sku", os_sku)
+ pulumi.set(__self__, "os_sku", os_sku)
if os_type is not None:
- _setter("os_type", os_type)
+ pulumi.set(__self__, "os_type", os_type)
if pod_subnet_ids is not None:
- _setter("pod_subnet_ids", pod_subnet_ids)
+ pulumi.set(__self__, "pod_subnet_ids", pod_subnet_ids)
if spot_percentage is not None:
- _setter("spot_percentage", spot_percentage)
+ pulumi.set(__self__, "spot_percentage", spot_percentage)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
if taints is not None:
- _setter("taints", taints)
+ pulumi.set(__self__, "taints", taints)
if vnet_subnet_ids is not None:
- _setter("vnet_subnet_ids", vnet_subnet_ids)
+ pulumi.set(__self__, "vnet_subnet_ids", vnet_subnet_ids)
@property
@pulumi.getter(name="availabilityZones")
@@ -746,10 +582,6 @@ def __init__(__self__, resource_name: str, *args, **kwargs):
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
- kwargs = kwargs or {}
- def _setter(key, value):
- kwargs[key] = value
- OceanNpVirtualNodeGroupArgs._configure(_setter, **kwargs)
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
@@ -788,7 +620,6 @@ def _internal_init(__self__,
__props__.__dict__["availability_zones"] = availability_zones
__props__.__dict__["enable_node_public_ip"] = enable_node_public_ip
__props__.__dict__["fallback_to_ondemand"] = fallback_to_ondemand
- filters = _utilities.configure(filters, OceanNpVirtualNodeGroupFiltersArgs, True)
__props__.__dict__["filters"] = filters
__props__.__dict__["headrooms"] = headrooms
__props__.__dict__["kubernetes_version"] = kubernetes_version
diff --git a/sdk/python/pulumi_spotinst/azure/ocean_virtual_node_group.py b/sdk/python/pulumi_spotinst/azure/ocean_virtual_node_group.py
index 1f551513..05046535 100644
--- a/sdk/python/pulumi_spotinst/azure/ocean_virtual_node_group.py
+++ b/sdk/python/pulumi_spotinst/azure/ocean_virtual_node_group.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs
from ._inputs import *
@@ -35,54 +35,21 @@ def __init__(__self__, *,
:param pulumi.Input[Sequence[pulumi.Input['OceanVirtualNodeGroupTaintArgs']]] taints: Additional taints for the virtual node group. Only custom user labels are allowed. Kubernetes built-in labels and Spot internal labels are not allowed.
:param pulumi.Input[Sequence[pulumi.Input[str]]] zones: An Array holding Availability Zones, this configures the availability zones the Ocean may launch instances in per VNG.
"""
- OceanVirtualNodeGroupArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- ocean_id=ocean_id,
- autoscales=autoscales,
- labels=labels,
- launch_specifications=launch_specifications,
- name=name,
- resource_limits=resource_limits,
- taints=taints,
- zones=zones,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- ocean_id: Optional[pulumi.Input[str]] = None,
- autoscales: Optional[pulumi.Input[Sequence[pulumi.Input['OceanVirtualNodeGroupAutoscaleArgs']]]] = None,
- labels: Optional[pulumi.Input[Sequence[pulumi.Input['OceanVirtualNodeGroupLabelArgs']]]] = None,
- launch_specifications: Optional[pulumi.Input[Sequence[pulumi.Input['OceanVirtualNodeGroupLaunchSpecificationArgs']]]] = None,
- name: Optional[pulumi.Input[str]] = None,
- resource_limits: Optional[pulumi.Input[Sequence[pulumi.Input['OceanVirtualNodeGroupResourceLimitArgs']]]] = None,
- taints: Optional[pulumi.Input[Sequence[pulumi.Input['OceanVirtualNodeGroupTaintArgs']]]] = None,
- zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if ocean_id is None and 'oceanId' in kwargs:
- ocean_id = kwargs['oceanId']
- if ocean_id is None:
- raise TypeError("Missing 'ocean_id' argument")
- if launch_specifications is None and 'launchSpecifications' in kwargs:
- launch_specifications = kwargs['launchSpecifications']
- if resource_limits is None and 'resourceLimits' in kwargs:
- resource_limits = kwargs['resourceLimits']
-
- _setter("ocean_id", ocean_id)
+ pulumi.set(__self__, "ocean_id", ocean_id)
if autoscales is not None:
- _setter("autoscales", autoscales)
+ pulumi.set(__self__, "autoscales", autoscales)
if labels is not None:
- _setter("labels", labels)
+ pulumi.set(__self__, "labels", labels)
if launch_specifications is not None:
- _setter("launch_specifications", launch_specifications)
+ pulumi.set(__self__, "launch_specifications", launch_specifications)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if resource_limits is not None:
- _setter("resource_limits", resource_limits)
+ pulumi.set(__self__, "resource_limits", resource_limits)
if taints is not None:
- _setter("taints", taints)
+ pulumi.set(__self__, "taints", taints)
if zones is not None:
- _setter("zones", zones)
+ pulumi.set(__self__, "zones", zones)
@property
@pulumi.getter(name="oceanId")
@@ -203,53 +170,22 @@ def __init__(__self__, *,
:param pulumi.Input[Sequence[pulumi.Input['OceanVirtualNodeGroupTaintArgs']]] taints: Additional taints for the virtual node group. Only custom user labels are allowed. Kubernetes built-in labels and Spot internal labels are not allowed.
:param pulumi.Input[Sequence[pulumi.Input[str]]] zones: An Array holding Availability Zones, this configures the availability zones the Ocean may launch instances in per VNG.
"""
- _OceanVirtualNodeGroupState._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- autoscales=autoscales,
- labels=labels,
- launch_specifications=launch_specifications,
- name=name,
- ocean_id=ocean_id,
- resource_limits=resource_limits,
- taints=taints,
- zones=zones,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- autoscales: Optional[pulumi.Input[Sequence[pulumi.Input['OceanVirtualNodeGroupAutoscaleArgs']]]] = None,
- labels: Optional[pulumi.Input[Sequence[pulumi.Input['OceanVirtualNodeGroupLabelArgs']]]] = None,
- launch_specifications: Optional[pulumi.Input[Sequence[pulumi.Input['OceanVirtualNodeGroupLaunchSpecificationArgs']]]] = None,
- name: Optional[pulumi.Input[str]] = None,
- ocean_id: Optional[pulumi.Input[str]] = None,
- resource_limits: Optional[pulumi.Input[Sequence[pulumi.Input['OceanVirtualNodeGroupResourceLimitArgs']]]] = None,
- taints: Optional[pulumi.Input[Sequence[pulumi.Input['OceanVirtualNodeGroupTaintArgs']]]] = None,
- zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if launch_specifications is None and 'launchSpecifications' in kwargs:
- launch_specifications = kwargs['launchSpecifications']
- if ocean_id is None and 'oceanId' in kwargs:
- ocean_id = kwargs['oceanId']
- if resource_limits is None and 'resourceLimits' in kwargs:
- resource_limits = kwargs['resourceLimits']
-
if autoscales is not None:
- _setter("autoscales", autoscales)
+ pulumi.set(__self__, "autoscales", autoscales)
if labels is not None:
- _setter("labels", labels)
+ pulumi.set(__self__, "labels", labels)
if launch_specifications is not None:
- _setter("launch_specifications", launch_specifications)
+ pulumi.set(__self__, "launch_specifications", launch_specifications)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if ocean_id is not None:
- _setter("ocean_id", ocean_id)
+ pulumi.set(__self__, "ocean_id", ocean_id)
if resource_limits is not None:
- _setter("resource_limits", resource_limits)
+ pulumi.set(__self__, "resource_limits", resource_limits)
if taints is not None:
- _setter("taints", taints)
+ pulumi.set(__self__, "taints", taints)
if zones is not None:
- _setter("zones", zones)
+ pulumi.set(__self__, "zones", zones)
@property
@pulumi.getter
@@ -503,10 +439,6 @@ def __init__(__self__, resource_name: str, *args, **kwargs):
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
- kwargs = kwargs or {}
- def _setter(key, value):
- kwargs[key] = value
- OceanVirtualNodeGroupArgs._configure(_setter, **kwargs)
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
diff --git a/sdk/python/pulumi_spotinst/azure/outputs.py b/sdk/python/pulumi_spotinst/azure/outputs.py
index 3eb86d72..238122d3 100644
--- a/sdk/python/pulumi_spotinst/azure/outputs.py
+++ b/sdk/python/pulumi_spotinst/azure/outputs.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs
@@ -100,34 +100,11 @@ def __init__(__self__, *,
health_check_type: str,
auto_healing: Optional[bool] = None,
grace_period: Optional[int] = None):
- ElastigroupHealthCheck._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- health_check_type=health_check_type,
- auto_healing=auto_healing,
- grace_period=grace_period,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- health_check_type: Optional[str] = None,
- auto_healing: Optional[bool] = None,
- grace_period: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if health_check_type is None and 'healthCheckType' in kwargs:
- health_check_type = kwargs['healthCheckType']
- if health_check_type is None:
- raise TypeError("Missing 'health_check_type' argument")
- if auto_healing is None and 'autoHealing' in kwargs:
- auto_healing = kwargs['autoHealing']
- if grace_period is None and 'gracePeriod' in kwargs:
- grace_period = kwargs['gracePeriod']
-
- _setter("health_check_type", health_check_type)
+ pulumi.set(__self__, "health_check_type", health_check_type)
if auto_healing is not None:
- _setter("auto_healing", auto_healing)
+ pulumi.set(__self__, "auto_healing", auto_healing)
if grace_period is not None:
- _setter("grace_period", grace_period)
+ pulumi.set(__self__, "grace_period", grace_period)
@property
@pulumi.getter(name="healthCheckType")
@@ -150,23 +127,10 @@ class ElastigroupImage(dict):
def __init__(__self__, *,
customs: Optional[Sequence['outputs.ElastigroupImageCustom']] = None,
marketplaces: Optional[Sequence['outputs.ElastigroupImageMarketplace']] = None):
- ElastigroupImage._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- customs=customs,
- marketplaces=marketplaces,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- customs: Optional[Sequence['outputs.ElastigroupImageCustom']] = None,
- marketplaces: Optional[Sequence['outputs.ElastigroupImageMarketplace']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if customs is not None:
- _setter("customs", customs)
+ pulumi.set(__self__, "customs", customs)
if marketplaces is not None:
- _setter("marketplaces", marketplaces)
+ pulumi.set(__self__, "marketplaces", marketplaces)
@property
@pulumi.getter
@@ -206,29 +170,8 @@ def __init__(__self__, *,
"""
:param str resource_group_name: Name of the Azure Resource Group where the Managed Service Identity is located.
"""
- ElastigroupImageCustom._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- image_name=image_name,
- resource_group_name=resource_group_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- image_name: Optional[str] = None,
- resource_group_name: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if image_name is None and 'imageName' in kwargs:
- image_name = kwargs['imageName']
- if image_name is None:
- raise TypeError("Missing 'image_name' argument")
- if resource_group_name is None and 'resourceGroupName' in kwargs:
- resource_group_name = kwargs['resourceGroupName']
- if resource_group_name is None:
- raise TypeError("Missing 'resource_group_name' argument")
-
- _setter("image_name", image_name)
- _setter("resource_group_name", resource_group_name)
+ pulumi.set(__self__, "image_name", image_name)
+ pulumi.set(__self__, "resource_group_name", resource_group_name)
@property
@pulumi.getter(name="imageName")
@@ -250,30 +193,9 @@ def __init__(__self__, *,
offer: str,
publisher: str,
sku: str):
- ElastigroupImageMarketplace._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- offer=offer,
- publisher=publisher,
- sku=sku,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- offer: Optional[str] = None,
- publisher: Optional[str] = None,
- sku: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if offer is None:
- raise TypeError("Missing 'offer' argument")
- if publisher is None:
- raise TypeError("Missing 'publisher' argument")
- if sku is None:
- raise TypeError("Missing 'sku' argument")
-
- _setter("offer", offer)
- _setter("publisher", publisher)
- _setter("sku", sku)
+ pulumi.set(__self__, "offer", offer)
+ pulumi.set(__self__, "publisher", publisher)
+ pulumi.set(__self__, "sku", sku)
@property
@pulumi.getter
@@ -312,22 +234,7 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
cluster_identifier: str):
- ElastigroupIntegrationKubernetes._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cluster_identifier=cluster_identifier,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cluster_identifier: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cluster_identifier is None and 'clusterIdentifier' in kwargs:
- cluster_identifier = kwargs['clusterIdentifier']
- if cluster_identifier is None:
- raise TypeError("Missing 'cluster_identifier' argument")
-
- _setter("cluster_identifier", cluster_identifier)
+ pulumi.set(__self__, "cluster_identifier", cluster_identifier)
@property
@pulumi.getter(name="clusterIdentifier")
@@ -356,22 +263,7 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
deployment_id: str):
- ElastigroupIntegrationMultaiRuntime._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- deployment_id=deployment_id,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- deployment_id: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if deployment_id is None and 'deploymentId' in kwargs:
- deployment_id = kwargs['deploymentId']
- if deployment_id is None:
- raise TypeError("Missing 'deployment_id' argument")
-
- _setter("deployment_id", deployment_id)
+ pulumi.set(__self__, "deployment_id", deployment_id)
@property
@pulumi.getter(name="deploymentId")
@@ -407,38 +299,13 @@ def __init__(__self__, *,
auto_weight: Optional[bool] = None,
balancer_id: Optional[str] = None,
target_set_id: Optional[str] = None):
- ElastigroupLoadBalancer._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- type=type,
- auto_weight=auto_weight,
- balancer_id=balancer_id,
- target_set_id=target_set_id,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- type: Optional[str] = None,
- auto_weight: Optional[bool] = None,
- balancer_id: Optional[str] = None,
- target_set_id: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if type is None:
- raise TypeError("Missing 'type' argument")
- if auto_weight is None and 'autoWeight' in kwargs:
- auto_weight = kwargs['autoWeight']
- if balancer_id is None and 'balancerId' in kwargs:
- balancer_id = kwargs['balancerId']
- if target_set_id is None and 'targetSetId' in kwargs:
- target_set_id = kwargs['targetSetId']
-
- _setter("type", type)
+ pulumi.set(__self__, "type", type)
if auto_weight is not None:
- _setter("auto_weight", auto_weight)
+ pulumi.set(__self__, "auto_weight", auto_weight)
if balancer_id is not None:
- _setter("balancer_id", balancer_id)
+ pulumi.set(__self__, "balancer_id", balancer_id)
if target_set_id is not None:
- _setter("target_set_id", target_set_id)
+ pulumi.set(__self__, "target_set_id", target_set_id)
@property
@pulumi.getter
@@ -486,32 +353,11 @@ def __init__(__self__, *,
user_name: str,
password: Optional[str] = None,
ssh_public_key: Optional[str] = None):
- ElastigroupLogin._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- user_name=user_name,
- password=password,
- ssh_public_key=ssh_public_key,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- user_name: Optional[str] = None,
- password: Optional[str] = None,
- ssh_public_key: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if user_name is None and 'userName' in kwargs:
- user_name = kwargs['userName']
- if user_name is None:
- raise TypeError("Missing 'user_name' argument")
- if ssh_public_key is None and 'sshPublicKey' in kwargs:
- ssh_public_key = kwargs['sshPublicKey']
-
- _setter("user_name", user_name)
+ pulumi.set(__self__, "user_name", user_name)
if password is not None:
- _setter("password", password)
+ pulumi.set(__self__, "password", password)
if ssh_public_key is not None:
- _setter("ssh_public_key", ssh_public_key)
+ pulumi.set(__self__, "ssh_public_key", ssh_public_key)
@property
@pulumi.getter(name="userName")
@@ -555,27 +401,8 @@ def __init__(__self__, *,
:param str name: Name of the Managed Service Identity.
:param str resource_group_name: Name of the Azure Resource Group where the Managed Service Identity is located.
"""
- ElastigroupManagedServiceIdentity._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- resource_group_name=resource_group_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[str] = None,
- resource_group_name: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
- if resource_group_name is None and 'resourceGroupName' in kwargs:
- resource_group_name = kwargs['resourceGroupName']
- if resource_group_name is None:
- raise TypeError("Missing 'resource_group_name' argument")
-
- _setter("name", name)
- _setter("resource_group_name", resource_group_name)
+ pulumi.set(__self__, "name", name)
+ pulumi.set(__self__, "resource_group_name", resource_group_name)
@property
@pulumi.getter
@@ -630,48 +457,13 @@ def __init__(__self__, *,
"""
:param str resource_group_name: Name of the Azure Resource Group where the Managed Service Identity is located.
"""
- ElastigroupNetwork._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- resource_group_name=resource_group_name,
- subnet_name=subnet_name,
- virtual_network_name=virtual_network_name,
- additional_ip_configs=additional_ip_configs,
- assign_public_ip=assign_public_ip,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- resource_group_name: Optional[str] = None,
- subnet_name: Optional[str] = None,
- virtual_network_name: Optional[str] = None,
- additional_ip_configs: Optional[Sequence['outputs.ElastigroupNetworkAdditionalIpConfig']] = None,
- assign_public_ip: Optional[bool] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if resource_group_name is None and 'resourceGroupName' in kwargs:
- resource_group_name = kwargs['resourceGroupName']
- if resource_group_name is None:
- raise TypeError("Missing 'resource_group_name' argument")
- if subnet_name is None and 'subnetName' in kwargs:
- subnet_name = kwargs['subnetName']
- if subnet_name is None:
- raise TypeError("Missing 'subnet_name' argument")
- if virtual_network_name is None and 'virtualNetworkName' in kwargs:
- virtual_network_name = kwargs['virtualNetworkName']
- if virtual_network_name is None:
- raise TypeError("Missing 'virtual_network_name' argument")
- if additional_ip_configs is None and 'additionalIpConfigs' in kwargs:
- additional_ip_configs = kwargs['additionalIpConfigs']
- if assign_public_ip is None and 'assignPublicIp' in kwargs:
- assign_public_ip = kwargs['assignPublicIp']
-
- _setter("resource_group_name", resource_group_name)
- _setter("subnet_name", subnet_name)
- _setter("virtual_network_name", virtual_network_name)
+ pulumi.set(__self__, "resource_group_name", resource_group_name)
+ pulumi.set(__self__, "subnet_name", subnet_name)
+ pulumi.set(__self__, "virtual_network_name", virtual_network_name)
if additional_ip_configs is not None:
- _setter("additional_ip_configs", additional_ip_configs)
+ pulumi.set(__self__, "additional_ip_configs", additional_ip_configs)
if assign_public_ip is not None:
- _setter("assign_public_ip", assign_public_ip)
+ pulumi.set(__self__, "assign_public_ip", assign_public_ip)
@property
@pulumi.getter(name="resourceGroupName")
@@ -727,26 +519,9 @@ def __init__(__self__, *,
"""
:param str name: Name of the Managed Service Identity.
"""
- ElastigroupNetworkAdditionalIpConfig._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- private_ip_version=private_ip_version,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[str] = None,
- private_ip_version: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
- if private_ip_version is None and 'privateIpVersion' in kwargs:
- private_ip_version = kwargs['privateIpVersion']
-
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if private_ip_version is not None:
- _setter("private_ip_version", private_ip_version)
+ pulumi.set(__self__, "private_ip_version", private_ip_version)
@property
@pulumi.getter
@@ -810,103 +585,38 @@ def __init__(__self__, *,
statistic: Optional[str] = None,
target: Optional[str] = None,
unit: Optional[str] = None):
- ElastigroupScalingDownPolicy._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- metric_name=metric_name,
- namespace=namespace,
- policy_name=policy_name,
- threshold=threshold,
- action_type=action_type,
- adjustment=adjustment,
- cooldown=cooldown,
- dimensions=dimensions,
- evaluation_periods=evaluation_periods,
- max_target_capacity=max_target_capacity,
- maximum=maximum,
- min_target_capacity=min_target_capacity,
- minimum=minimum,
- operator=operator,
- period=period,
- statistic=statistic,
- target=target,
- unit=unit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- metric_name: Optional[str] = None,
- namespace: Optional[str] = None,
- policy_name: Optional[str] = None,
- threshold: Optional[float] = None,
- action_type: Optional[str] = None,
- adjustment: Optional[str] = None,
- cooldown: Optional[int] = None,
- dimensions: Optional[Sequence['outputs.ElastigroupScalingDownPolicyDimension']] = None,
- evaluation_periods: Optional[int] = None,
- max_target_capacity: Optional[str] = None,
- maximum: Optional[str] = None,
- min_target_capacity: Optional[str] = None,
- minimum: Optional[str] = None,
- operator: Optional[str] = None,
- period: Optional[int] = None,
- statistic: Optional[str] = None,
- target: Optional[str] = None,
- unit: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if metric_name is None and 'metricName' in kwargs:
- metric_name = kwargs['metricName']
- if metric_name is None:
- raise TypeError("Missing 'metric_name' argument")
- if namespace is None:
- raise TypeError("Missing 'namespace' argument")
- if policy_name is None and 'policyName' in kwargs:
- policy_name = kwargs['policyName']
- if policy_name is None:
- raise TypeError("Missing 'policy_name' argument")
- if threshold is None:
- raise TypeError("Missing 'threshold' argument")
- if action_type is None and 'actionType' in kwargs:
- action_type = kwargs['actionType']
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
- if max_target_capacity is None and 'maxTargetCapacity' in kwargs:
- max_target_capacity = kwargs['maxTargetCapacity']
- if min_target_capacity is None and 'minTargetCapacity' in kwargs:
- min_target_capacity = kwargs['minTargetCapacity']
-
- _setter("metric_name", metric_name)
- _setter("namespace", namespace)
- _setter("policy_name", policy_name)
- _setter("threshold", threshold)
+ pulumi.set(__self__, "metric_name", metric_name)
+ pulumi.set(__self__, "namespace", namespace)
+ pulumi.set(__self__, "policy_name", policy_name)
+ pulumi.set(__self__, "threshold", threshold)
if action_type is not None:
- _setter("action_type", action_type)
+ pulumi.set(__self__, "action_type", action_type)
if adjustment is not None:
- _setter("adjustment", adjustment)
+ pulumi.set(__self__, "adjustment", adjustment)
if cooldown is not None:
- _setter("cooldown", cooldown)
+ pulumi.set(__self__, "cooldown", cooldown)
if dimensions is not None:
- _setter("dimensions", dimensions)
+ pulumi.set(__self__, "dimensions", dimensions)
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
if max_target_capacity is not None:
- _setter("max_target_capacity", max_target_capacity)
+ pulumi.set(__self__, "max_target_capacity", max_target_capacity)
if maximum is not None:
- _setter("maximum", maximum)
+ pulumi.set(__self__, "maximum", maximum)
if min_target_capacity is not None:
- _setter("min_target_capacity", min_target_capacity)
+ pulumi.set(__self__, "min_target_capacity", min_target_capacity)
if minimum is not None:
- _setter("minimum", minimum)
+ pulumi.set(__self__, "minimum", minimum)
if operator is not None:
- _setter("operator", operator)
+ pulumi.set(__self__, "operator", operator)
if period is not None:
- _setter("period", period)
+ pulumi.set(__self__, "period", period)
if statistic is not None:
- _setter("statistic", statistic)
+ pulumi.set(__self__, "statistic", statistic)
if target is not None:
- _setter("target", target)
+ pulumi.set(__self__, "target", target)
if unit is not None:
- _setter("unit", unit)
+ pulumi.set(__self__, "unit", unit)
@property
@pulumi.getter(name="metricName")
@@ -1008,24 +718,9 @@ def __init__(__self__, *,
:param str name: Name of the Managed Service Identity.
:param str value: Tag Value for Vms in Elastigroup.
"""
- ElastigroupScalingDownPolicyDimension._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
-
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if value is not None:
- _setter("value", value)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -1092,103 +787,38 @@ def __init__(__self__, *,
statistic: Optional[str] = None,
target: Optional[str] = None,
unit: Optional[str] = None):
- ElastigroupScalingUpPolicy._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- metric_name=metric_name,
- namespace=namespace,
- policy_name=policy_name,
- threshold=threshold,
- action_type=action_type,
- adjustment=adjustment,
- cooldown=cooldown,
- dimensions=dimensions,
- evaluation_periods=evaluation_periods,
- max_target_capacity=max_target_capacity,
- maximum=maximum,
- min_target_capacity=min_target_capacity,
- minimum=minimum,
- operator=operator,
- period=period,
- statistic=statistic,
- target=target,
- unit=unit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- metric_name: Optional[str] = None,
- namespace: Optional[str] = None,
- policy_name: Optional[str] = None,
- threshold: Optional[float] = None,
- action_type: Optional[str] = None,
- adjustment: Optional[str] = None,
- cooldown: Optional[int] = None,
- dimensions: Optional[Sequence['outputs.ElastigroupScalingUpPolicyDimension']] = None,
- evaluation_periods: Optional[int] = None,
- max_target_capacity: Optional[str] = None,
- maximum: Optional[str] = None,
- min_target_capacity: Optional[str] = None,
- minimum: Optional[str] = None,
- operator: Optional[str] = None,
- period: Optional[int] = None,
- statistic: Optional[str] = None,
- target: Optional[str] = None,
- unit: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if metric_name is None and 'metricName' in kwargs:
- metric_name = kwargs['metricName']
- if metric_name is None:
- raise TypeError("Missing 'metric_name' argument")
- if namespace is None:
- raise TypeError("Missing 'namespace' argument")
- if policy_name is None and 'policyName' in kwargs:
- policy_name = kwargs['policyName']
- if policy_name is None:
- raise TypeError("Missing 'policy_name' argument")
- if threshold is None:
- raise TypeError("Missing 'threshold' argument")
- if action_type is None and 'actionType' in kwargs:
- action_type = kwargs['actionType']
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
- if max_target_capacity is None and 'maxTargetCapacity' in kwargs:
- max_target_capacity = kwargs['maxTargetCapacity']
- if min_target_capacity is None and 'minTargetCapacity' in kwargs:
- min_target_capacity = kwargs['minTargetCapacity']
-
- _setter("metric_name", metric_name)
- _setter("namespace", namespace)
- _setter("policy_name", policy_name)
- _setter("threshold", threshold)
+ pulumi.set(__self__, "metric_name", metric_name)
+ pulumi.set(__self__, "namespace", namespace)
+ pulumi.set(__self__, "policy_name", policy_name)
+ pulumi.set(__self__, "threshold", threshold)
if action_type is not None:
- _setter("action_type", action_type)
+ pulumi.set(__self__, "action_type", action_type)
if adjustment is not None:
- _setter("adjustment", adjustment)
+ pulumi.set(__self__, "adjustment", adjustment)
if cooldown is not None:
- _setter("cooldown", cooldown)
+ pulumi.set(__self__, "cooldown", cooldown)
if dimensions is not None:
- _setter("dimensions", dimensions)
+ pulumi.set(__self__, "dimensions", dimensions)
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
if max_target_capacity is not None:
- _setter("max_target_capacity", max_target_capacity)
+ pulumi.set(__self__, "max_target_capacity", max_target_capacity)
if maximum is not None:
- _setter("maximum", maximum)
+ pulumi.set(__self__, "maximum", maximum)
if min_target_capacity is not None:
- _setter("min_target_capacity", min_target_capacity)
+ pulumi.set(__self__, "min_target_capacity", min_target_capacity)
if minimum is not None:
- _setter("minimum", minimum)
+ pulumi.set(__self__, "minimum", minimum)
if operator is not None:
- _setter("operator", operator)
+ pulumi.set(__self__, "operator", operator)
if period is not None:
- _setter("period", period)
+ pulumi.set(__self__, "period", period)
if statistic is not None:
- _setter("statistic", statistic)
+ pulumi.set(__self__, "statistic", statistic)
if target is not None:
- _setter("target", target)
+ pulumi.set(__self__, "target", target)
if unit is not None:
- _setter("unit", unit)
+ pulumi.set(__self__, "unit", unit)
@property
@pulumi.getter(name="metricName")
@@ -1290,24 +920,9 @@ def __init__(__self__, *,
:param str name: Name of the Managed Service Identity.
:param str value: Tag Value for Vms in Elastigroup.
"""
- ElastigroupScalingUpPolicyDimension._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
-
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if value is not None:
- _setter("value", value)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -1372,75 +987,24 @@ def __init__(__self__, *,
scale_max_capacity: Optional[str] = None,
scale_min_capacity: Optional[str] = None,
scale_target_capacity: Optional[str] = None):
- ElastigroupScheduledTask._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cron_expression=cron_expression,
- task_type=task_type,
- adjustment=adjustment,
- adjustment_percentage=adjustment_percentage,
- batch_size_percentage=batch_size_percentage,
- grace_period=grace_period,
- is_enabled=is_enabled,
- scale_max_capacity=scale_max_capacity,
- scale_min_capacity=scale_min_capacity,
- scale_target_capacity=scale_target_capacity,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cron_expression: Optional[str] = None,
- task_type: Optional[str] = None,
- adjustment: Optional[str] = None,
- adjustment_percentage: Optional[str] = None,
- batch_size_percentage: Optional[str] = None,
- grace_period: Optional[str] = None,
- is_enabled: Optional[bool] = None,
- scale_max_capacity: Optional[str] = None,
- scale_min_capacity: Optional[str] = None,
- scale_target_capacity: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cron_expression is None and 'cronExpression' in kwargs:
- cron_expression = kwargs['cronExpression']
- if cron_expression is None:
- raise TypeError("Missing 'cron_expression' argument")
- if task_type is None and 'taskType' in kwargs:
- task_type = kwargs['taskType']
- if task_type is None:
- raise TypeError("Missing 'task_type' argument")
- if adjustment_percentage is None and 'adjustmentPercentage' in kwargs:
- adjustment_percentage = kwargs['adjustmentPercentage']
- if batch_size_percentage is None and 'batchSizePercentage' in kwargs:
- batch_size_percentage = kwargs['batchSizePercentage']
- if grace_period is None and 'gracePeriod' in kwargs:
- grace_period = kwargs['gracePeriod']
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
- if scale_max_capacity is None and 'scaleMaxCapacity' in kwargs:
- scale_max_capacity = kwargs['scaleMaxCapacity']
- if scale_min_capacity is None and 'scaleMinCapacity' in kwargs:
- scale_min_capacity = kwargs['scaleMinCapacity']
- if scale_target_capacity is None and 'scaleTargetCapacity' in kwargs:
- scale_target_capacity = kwargs['scaleTargetCapacity']
-
- _setter("cron_expression", cron_expression)
- _setter("task_type", task_type)
+ pulumi.set(__self__, "cron_expression", cron_expression)
+ pulumi.set(__self__, "task_type", task_type)
if adjustment is not None:
- _setter("adjustment", adjustment)
+ pulumi.set(__self__, "adjustment", adjustment)
if adjustment_percentage is not None:
- _setter("adjustment_percentage", adjustment_percentage)
+ pulumi.set(__self__, "adjustment_percentage", adjustment_percentage)
if batch_size_percentage is not None:
- _setter("batch_size_percentage", batch_size_percentage)
+ pulumi.set(__self__, "batch_size_percentage", batch_size_percentage)
if grace_period is not None:
- _setter("grace_period", grace_period)
+ pulumi.set(__self__, "grace_period", grace_period)
if is_enabled is not None:
- _setter("is_enabled", is_enabled)
+ pulumi.set(__self__, "is_enabled", is_enabled)
if scale_max_capacity is not None:
- _setter("scale_max_capacity", scale_max_capacity)
+ pulumi.set(__self__, "scale_max_capacity", scale_max_capacity)
if scale_min_capacity is not None:
- _setter("scale_min_capacity", scale_min_capacity)
+ pulumi.set(__self__, "scale_min_capacity", scale_min_capacity)
if scale_target_capacity is not None:
- _setter("scale_target_capacity", scale_target_capacity)
+ pulumi.set(__self__, "scale_target_capacity", scale_target_capacity)
@property
@pulumi.getter(name="cronExpression")
@@ -1520,33 +1084,12 @@ def __init__(__self__, *,
draining_timeout: Optional[int] = None,
low_priority_percentage: Optional[int] = None,
od_count: Optional[int] = None):
- ElastigroupStrategy._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- draining_timeout=draining_timeout,
- low_priority_percentage=low_priority_percentage,
- od_count=od_count,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- draining_timeout: Optional[int] = None,
- low_priority_percentage: Optional[int] = None,
- od_count: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if draining_timeout is None and 'drainingTimeout' in kwargs:
- draining_timeout = kwargs['drainingTimeout']
- if low_priority_percentage is None and 'lowPriorityPercentage' in kwargs:
- low_priority_percentage = kwargs['lowPriorityPercentage']
- if od_count is None and 'odCount' in kwargs:
- od_count = kwargs['odCount']
-
if draining_timeout is not None:
- _setter("draining_timeout", draining_timeout)
+ pulumi.set(__self__, "draining_timeout", draining_timeout)
if low_priority_percentage is not None:
- _setter("low_priority_percentage", low_priority_percentage)
+ pulumi.set(__self__, "low_priority_percentage", low_priority_percentage)
if od_count is not None:
- _setter("od_count", od_count)
+ pulumi.set(__self__, "od_count", od_count)
@property
@pulumi.getter(name="drainingTimeout")
@@ -1588,28 +1131,9 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
should_roll: bool,
roll_config: Optional['outputs.ElastigroupUpdatePolicyRollConfig'] = None):
- ElastigroupUpdatePolicy._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- should_roll=should_roll,
- roll_config=roll_config,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- should_roll: Optional[bool] = None,
- roll_config: Optional['outputs.ElastigroupUpdatePolicyRollConfig'] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if should_roll is None and 'shouldRoll' in kwargs:
- should_roll = kwargs['shouldRoll']
- if should_roll is None:
- raise TypeError("Missing 'should_roll' argument")
- if roll_config is None and 'rollConfig' in kwargs:
- roll_config = kwargs['rollConfig']
-
- _setter("should_roll", should_roll)
+ pulumi.set(__self__, "should_roll", should_roll)
if roll_config is not None:
- _setter("roll_config", roll_config)
+ pulumi.set(__self__, "roll_config", roll_config)
@property
@pulumi.getter(name="shouldRoll")
@@ -1649,34 +1173,11 @@ def __init__(__self__, *,
batch_size_percentage: int,
grace_period: Optional[int] = None,
health_check_type: Optional[str] = None):
- ElastigroupUpdatePolicyRollConfig._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- batch_size_percentage=batch_size_percentage,
- grace_period=grace_period,
- health_check_type=health_check_type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- batch_size_percentage: Optional[int] = None,
- grace_period: Optional[int] = None,
- health_check_type: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if batch_size_percentage is None and 'batchSizePercentage' in kwargs:
- batch_size_percentage = kwargs['batchSizePercentage']
- if batch_size_percentage is None:
- raise TypeError("Missing 'batch_size_percentage' argument")
- if grace_period is None and 'gracePeriod' in kwargs:
- grace_period = kwargs['gracePeriod']
- if health_check_type is None and 'healthCheckType' in kwargs:
- health_check_type = kwargs['healthCheckType']
-
- _setter("batch_size_percentage", batch_size_percentage)
+ pulumi.set(__self__, "batch_size_percentage", batch_size_percentage)
if grace_period is not None:
- _setter("grace_period", grace_period)
+ pulumi.set(__self__, "grace_period", grace_period)
if health_check_type is not None:
- _setter("health_check_type", health_check_type)
+ pulumi.set(__self__, "health_check_type", health_check_type)
@property
@pulumi.getter(name="batchSizePercentage")
@@ -1730,39 +1231,14 @@ def __init__(__self__, *,
:param bool autoscale_is_enabled: Enable the Ocean Kubernetes Autoscaler.
:param 'OceanAutoscalerResourceLimitsArgs' resource_limits: Optionally set upper and lower bounds on the resource usage of the cluster.
"""
- OceanAutoscaler._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- autoscale_down=autoscale_down,
- autoscale_headroom=autoscale_headroom,
- autoscale_is_enabled=autoscale_is_enabled,
- resource_limits=resource_limits,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- autoscale_down: Optional['outputs.OceanAutoscalerAutoscaleDown'] = None,
- autoscale_headroom: Optional['outputs.OceanAutoscalerAutoscaleHeadroom'] = None,
- autoscale_is_enabled: Optional[bool] = None,
- resource_limits: Optional['outputs.OceanAutoscalerResourceLimits'] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if autoscale_down is None and 'autoscaleDown' in kwargs:
- autoscale_down = kwargs['autoscaleDown']
- if autoscale_headroom is None and 'autoscaleHeadroom' in kwargs:
- autoscale_headroom = kwargs['autoscaleHeadroom']
- if autoscale_is_enabled is None and 'autoscaleIsEnabled' in kwargs:
- autoscale_is_enabled = kwargs['autoscaleIsEnabled']
- if resource_limits is None and 'resourceLimits' in kwargs:
- resource_limits = kwargs['resourceLimits']
-
if autoscale_down is not None:
- _setter("autoscale_down", autoscale_down)
+ pulumi.set(__self__, "autoscale_down", autoscale_down)
if autoscale_headroom is not None:
- _setter("autoscale_headroom", autoscale_headroom)
+ pulumi.set(__self__, "autoscale_headroom", autoscale_headroom)
if autoscale_is_enabled is not None:
- _setter("autoscale_is_enabled", autoscale_is_enabled)
+ pulumi.set(__self__, "autoscale_is_enabled", autoscale_is_enabled)
if resource_limits is not None:
- _setter("resource_limits", resource_limits)
+ pulumi.set(__self__, "resource_limits", resource_limits)
@property
@pulumi.getter(name="autoscaleDown")
@@ -1821,21 +1297,8 @@ def __init__(__self__, *,
"""
:param float max_scale_down_percentage: Would represent the maximum % to scale-down.
"""
- OceanAutoscalerAutoscaleDown._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- max_scale_down_percentage=max_scale_down_percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- max_scale_down_percentage: Optional[float] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if max_scale_down_percentage is None and 'maxScaleDownPercentage' in kwargs:
- max_scale_down_percentage = kwargs['maxScaleDownPercentage']
-
if max_scale_down_percentage is not None:
- _setter("max_scale_down_percentage", max_scale_down_percentage)
+ pulumi.set(__self__, "max_scale_down_percentage", max_scale_down_percentage)
@property
@pulumi.getter(name="maxScaleDownPercentage")
@@ -1853,19 +1316,8 @@ def __init__(__self__, *,
"""
:param 'OceanAutoscalerAutoscaleHeadroomAutomaticArgs' automatic: Automatic headroom configuration.
"""
- OceanAutoscalerAutoscaleHeadroom._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- automatic=automatic,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- automatic: Optional['outputs.OceanAutoscalerAutoscaleHeadroomAutomatic'] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if automatic is not None:
- _setter("automatic", automatic)
+ pulumi.set(__self__, "automatic", automatic)
@property
@pulumi.getter
@@ -1902,25 +1354,10 @@ def __init__(__self__, *,
:param bool is_enabled: Enable automatic headroom. When set to `true`, Ocean configures and optimizes headroom automatically.
:param int percentage: Optionally set a number between 0-100 to control the percentage of total cluster resources dedicated to headroom. Relevant when `isEnabled` is toggled on.
"""
- OceanAutoscalerAutoscaleHeadroomAutomatic._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- is_enabled=is_enabled,
- percentage=percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- is_enabled: Optional[bool] = None,
- percentage: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
-
if is_enabled is not None:
- _setter("is_enabled", is_enabled)
+ pulumi.set(__self__, "is_enabled", is_enabled)
if percentage is not None:
- _setter("percentage", percentage)
+ pulumi.set(__self__, "percentage", percentage)
@property
@pulumi.getter(name="isEnabled")
@@ -1967,27 +1404,10 @@ def __init__(__self__, *,
:param int max_memory_gib: The maximum memory in GiB units that can be allocated to the cluster.
:param int max_vcpu: The maximum cpu in vCpu units that can be allocated to the cluster.
"""
- OceanAutoscalerResourceLimits._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- max_memory_gib=max_memory_gib,
- max_vcpu=max_vcpu,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- max_memory_gib: Optional[int] = None,
- max_vcpu: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if max_memory_gib is None and 'maxMemoryGib' in kwargs:
- max_memory_gib = kwargs['maxMemoryGib']
- if max_vcpu is None and 'maxVcpu' in kwargs:
- max_vcpu = kwargs['maxVcpu']
-
if max_memory_gib is not None:
- _setter("max_memory_gib", max_memory_gib)
+ pulumi.set(__self__, "max_memory_gib", max_memory_gib)
if max_vcpu is not None:
- _setter("max_vcpu", max_vcpu)
+ pulumi.set(__self__, "max_vcpu", max_vcpu)
@property
@pulumi.getter(name="maxMemoryGib")
@@ -2040,39 +1460,16 @@ def __init__(__self__, *,
:param str publisher: Image publisher.
:param str type: The type of load balancer. Supported value: `loadBalancer`
"""
- OceanExtension._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- api_version=api_version,
- minor_version_auto_upgrade=minor_version_auto_upgrade,
- name=name,
- publisher=publisher,
- type=type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- api_version: Optional[str] = None,
- minor_version_auto_upgrade: Optional[bool] = None,
- name: Optional[str] = None,
- publisher: Optional[str] = None,
- type: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if api_version is None and 'apiVersion' in kwargs:
- api_version = kwargs['apiVersion']
- if minor_version_auto_upgrade is None and 'minorVersionAutoUpgrade' in kwargs:
- minor_version_auto_upgrade = kwargs['minorVersionAutoUpgrade']
-
if api_version is not None:
- _setter("api_version", api_version)
+ pulumi.set(__self__, "api_version", api_version)
if minor_version_auto_upgrade is not None:
- _setter("minor_version_auto_upgrade", minor_version_auto_upgrade)
+ pulumi.set(__self__, "minor_version_auto_upgrade", minor_version_auto_upgrade)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if publisher is not None:
- _setter("publisher", publisher)
+ pulumi.set(__self__, "publisher", publisher)
if type is not None:
- _setter("type", type)
+ pulumi.set(__self__, "type", type)
@property
@pulumi.getter(name="apiVersion")
@@ -2139,21 +1536,8 @@ def __init__(__self__, *,
"""
:param int grace_period: The amount of time to wait, in seconds, from the moment the instance has launched before monitoring its health checks.
"""
- OceanHealth._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- grace_period=grace_period,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- grace_period: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if grace_period is None and 'gracePeriod' in kwargs:
- grace_period = kwargs['gracePeriod']
-
if grace_period is not None:
- _setter("grace_period", grace_period)
+ pulumi.set(__self__, "grace_period", grace_period)
@property
@pulumi.getter(name="gracePeriod")
@@ -2171,19 +1555,8 @@ def __init__(__self__, *,
"""
:param Sequence['OceanImageMarketplaceArgs'] marketplaces: Select an image from Azure's Marketplace image catalogue.
"""
- OceanImage._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- marketplaces=marketplaces,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- marketplaces: Optional[Sequence['outputs.OceanImageMarketplace']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if marketplaces is not None:
- _setter("marketplaces", marketplaces)
+ pulumi.set(__self__, "marketplaces", marketplaces)
@property
@pulumi.getter
@@ -2207,31 +1580,14 @@ def __init__(__self__, *,
:param str sku: Image Stock Keeping Unit (which is the specific version of the image).
:param str version: Image version.
"""
- OceanImageMarketplace._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- offer=offer,
- publisher=publisher,
- sku=sku,
- version=version,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- offer: Optional[str] = None,
- publisher: Optional[str] = None,
- sku: Optional[str] = None,
- version: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if offer is not None:
- _setter("offer", offer)
+ pulumi.set(__self__, "offer", offer)
if publisher is not None:
- _setter("publisher", publisher)
+ pulumi.set(__self__, "publisher", publisher)
if sku is not None:
- _setter("sku", sku)
+ pulumi.set(__self__, "sku", sku)
if version is not None:
- _setter("version", version)
+ pulumi.set(__self__, "version", version)
@property
@pulumi.getter
@@ -2302,41 +1658,16 @@ def __init__(__self__, *,
:param str resource_group_name: The Resource Group name of the Load Balancer.
:param str type: The type of load balancer. Supported value: `loadBalancer`
"""
- OceanLoadBalancer._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- backend_pool_names=backend_pool_names,
- load_balancer_sku=load_balancer_sku,
- name=name,
- resource_group_name=resource_group_name,
- type=type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- backend_pool_names: Optional[Sequence[str]] = None,
- load_balancer_sku: Optional[str] = None,
- name: Optional[str] = None,
- resource_group_name: Optional[str] = None,
- type: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if backend_pool_names is None and 'backendPoolNames' in kwargs:
- backend_pool_names = kwargs['backendPoolNames']
- if load_balancer_sku is None and 'loadBalancerSku' in kwargs:
- load_balancer_sku = kwargs['loadBalancerSku']
- if resource_group_name is None and 'resourceGroupName' in kwargs:
- resource_group_name = kwargs['resourceGroupName']
-
if backend_pool_names is not None:
- _setter("backend_pool_names", backend_pool_names)
+ pulumi.set(__self__, "backend_pool_names", backend_pool_names)
if load_balancer_sku is not None:
- _setter("load_balancer_sku", load_balancer_sku)
+ pulumi.set(__self__, "load_balancer_sku", load_balancer_sku)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if resource_group_name is not None:
- _setter("resource_group_name", resource_group_name)
+ pulumi.set(__self__, "resource_group_name", resource_group_name)
if type is not None:
- _setter("type", type)
+ pulumi.set(__self__, "type", type)
@property
@pulumi.getter(name="backendPoolNames")
@@ -2405,27 +1736,8 @@ def __init__(__self__, *,
:param str name: Name of the Load Balancer.
:param str resource_group_name: The Resource Group name of the Load Balancer.
"""
- OceanManagedServiceIdentity._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- resource_group_name=resource_group_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[str] = None,
- resource_group_name: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
- if resource_group_name is None and 'resourceGroupName' in kwargs:
- resource_group_name = kwargs['resourceGroupName']
- if resource_group_name is None:
- raise TypeError("Missing 'resource_group_name' argument")
-
- _setter("name", name)
- _setter("resource_group_name", resource_group_name)
+ pulumi.set(__self__, "name", name)
+ pulumi.set(__self__, "resource_group_name", resource_group_name)
@property
@pulumi.getter
@@ -2476,33 +1788,12 @@ def __init__(__self__, *,
:param str resource_group_name: The Resource Group name of the Load Balancer.
:param str virtual_network_name: Virtual network.
"""
- OceanNetwork._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- network_interfaces=network_interfaces,
- resource_group_name=resource_group_name,
- virtual_network_name=virtual_network_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- network_interfaces: Optional[Sequence['outputs.OceanNetworkNetworkInterface']] = None,
- resource_group_name: Optional[str] = None,
- virtual_network_name: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if network_interfaces is None and 'networkInterfaces' in kwargs:
- network_interfaces = kwargs['networkInterfaces']
- if resource_group_name is None and 'resourceGroupName' in kwargs:
- resource_group_name = kwargs['resourceGroupName']
- if virtual_network_name is None and 'virtualNetworkName' in kwargs:
- virtual_network_name = kwargs['virtualNetworkName']
-
if network_interfaces is not None:
- _setter("network_interfaces", network_interfaces)
+ pulumi.set(__self__, "network_interfaces", network_interfaces)
if resource_group_name is not None:
- _setter("resource_group_name", resource_group_name)
+ pulumi.set(__self__, "resource_group_name", resource_group_name)
if virtual_network_name is not None:
- _setter("virtual_network_name", virtual_network_name)
+ pulumi.set(__self__, "virtual_network_name", virtual_network_name)
@property
@pulumi.getter(name="networkInterfaces")
@@ -2568,45 +1859,16 @@ def __init__(__self__, *,
:param bool is_primary: Defines whether the network interface is primary or not.
:param str subnet_name: Subnet name.
"""
- OceanNetworkNetworkInterface._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- additional_ip_configs=additional_ip_configs,
- assign_public_ip=assign_public_ip,
- is_primary=is_primary,
- security_group=security_group,
- subnet_name=subnet_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- additional_ip_configs: Optional[Sequence['outputs.OceanNetworkNetworkInterfaceAdditionalIpConfig']] = None,
- assign_public_ip: Optional[bool] = None,
- is_primary: Optional[bool] = None,
- security_group: Optional['outputs.OceanNetworkNetworkInterfaceSecurityGroup'] = None,
- subnet_name: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if additional_ip_configs is None and 'additionalIpConfigs' in kwargs:
- additional_ip_configs = kwargs['additionalIpConfigs']
- if assign_public_ip is None and 'assignPublicIp' in kwargs:
- assign_public_ip = kwargs['assignPublicIp']
- if is_primary is None and 'isPrimary' in kwargs:
- is_primary = kwargs['isPrimary']
- if security_group is None and 'securityGroup' in kwargs:
- security_group = kwargs['securityGroup']
- if subnet_name is None and 'subnetName' in kwargs:
- subnet_name = kwargs['subnetName']
-
if additional_ip_configs is not None:
- _setter("additional_ip_configs", additional_ip_configs)
+ pulumi.set(__self__, "additional_ip_configs", additional_ip_configs)
if assign_public_ip is not None:
- _setter("assign_public_ip", assign_public_ip)
+ pulumi.set(__self__, "assign_public_ip", assign_public_ip)
if is_primary is not None:
- _setter("is_primary", is_primary)
+ pulumi.set(__self__, "is_primary", is_primary)
if security_group is not None:
- _setter("security_group", security_group)
+ pulumi.set(__self__, "security_group", security_group)
if subnet_name is not None:
- _setter("subnet_name", subnet_name)
+ pulumi.set(__self__, "subnet_name", subnet_name)
@property
@pulumi.getter(name="additionalIpConfigs")
@@ -2672,25 +1934,10 @@ def __init__(__self__, *,
:param str name: Name of the Load Balancer.
:param str private_ip_version: Supported values: `IPv4`, `IPv6`.
"""
- OceanNetworkNetworkInterfaceAdditionalIpConfig._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- private_ip_version=private_ip_version,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[str] = None,
- private_ip_version: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if private_ip_version is None and 'privateIpVersion' in kwargs:
- private_ip_version = kwargs['privateIpVersion']
-
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if private_ip_version is not None:
- _setter("private_ip_version", private_ip_version)
+ pulumi.set(__self__, "private_ip_version", private_ip_version)
@property
@pulumi.getter
@@ -2735,25 +1982,10 @@ def __init__(__self__, *,
:param str name: Name of the Load Balancer.
:param str resource_group_name: The Resource Group name of the Load Balancer.
"""
- OceanNetworkNetworkInterfaceSecurityGroup._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- resource_group_name=resource_group_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[str] = None,
- resource_group_name: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if resource_group_name is None and 'resourceGroupName' in kwargs:
- resource_group_name = kwargs['resourceGroupName']
-
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if resource_group_name is not None:
- _setter("resource_group_name", resource_group_name)
+ pulumi.set(__self__, "resource_group_name", resource_group_name)
@property
@pulumi.getter
@@ -2802,39 +2034,14 @@ def __init__(__self__, *,
autoscale_headroom: Optional['outputs.OceanNpAutoscalerAutoscaleHeadroom'] = None,
autoscale_is_enabled: Optional[bool] = None,
resource_limits: Optional['outputs.OceanNpAutoscalerResourceLimits'] = None):
- OceanNpAutoscaler._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- autoscale_down=autoscale_down,
- autoscale_headroom=autoscale_headroom,
- autoscale_is_enabled=autoscale_is_enabled,
- resource_limits=resource_limits,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- autoscale_down: Optional['outputs.OceanNpAutoscalerAutoscaleDown'] = None,
- autoscale_headroom: Optional['outputs.OceanNpAutoscalerAutoscaleHeadroom'] = None,
- autoscale_is_enabled: Optional[bool] = None,
- resource_limits: Optional['outputs.OceanNpAutoscalerResourceLimits'] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if autoscale_down is None and 'autoscaleDown' in kwargs:
- autoscale_down = kwargs['autoscaleDown']
- if autoscale_headroom is None and 'autoscaleHeadroom' in kwargs:
- autoscale_headroom = kwargs['autoscaleHeadroom']
- if autoscale_is_enabled is None and 'autoscaleIsEnabled' in kwargs:
- autoscale_is_enabled = kwargs['autoscaleIsEnabled']
- if resource_limits is None and 'resourceLimits' in kwargs:
- resource_limits = kwargs['resourceLimits']
-
if autoscale_down is not None:
- _setter("autoscale_down", autoscale_down)
+ pulumi.set(__self__, "autoscale_down", autoscale_down)
if autoscale_headroom is not None:
- _setter("autoscale_headroom", autoscale_headroom)
+ pulumi.set(__self__, "autoscale_headroom", autoscale_headroom)
if autoscale_is_enabled is not None:
- _setter("autoscale_is_enabled", autoscale_is_enabled)
+ pulumi.set(__self__, "autoscale_is_enabled", autoscale_is_enabled)
if resource_limits is not None:
- _setter("resource_limits", resource_limits)
+ pulumi.set(__self__, "resource_limits", resource_limits)
@property
@pulumi.getter(name="autoscaleDown")
@@ -2878,21 +2085,8 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
max_scale_down_percentage: Optional[int] = None):
- OceanNpAutoscalerAutoscaleDown._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- max_scale_down_percentage=max_scale_down_percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- max_scale_down_percentage: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if max_scale_down_percentage is None and 'maxScaleDownPercentage' in kwargs:
- max_scale_down_percentage = kwargs['maxScaleDownPercentage']
-
if max_scale_down_percentage is not None:
- _setter("max_scale_down_percentage", max_scale_down_percentage)
+ pulumi.set(__self__, "max_scale_down_percentage", max_scale_down_percentage)
@property
@pulumi.getter(name="maxScaleDownPercentage")
@@ -2904,19 +2098,8 @@ def max_scale_down_percentage(self) -> Optional[int]:
class OceanNpAutoscalerAutoscaleHeadroom(dict):
def __init__(__self__, *,
automatic: Optional['outputs.OceanNpAutoscalerAutoscaleHeadroomAutomatic'] = None):
- OceanNpAutoscalerAutoscaleHeadroom._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- automatic=automatic,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- automatic: Optional['outputs.OceanNpAutoscalerAutoscaleHeadroomAutomatic'] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if automatic is not None:
- _setter("automatic", automatic)
+ pulumi.set(__self__, "automatic", automatic)
@property
@pulumi.getter
@@ -2928,19 +2111,8 @@ def automatic(self) -> Optional['outputs.OceanNpAutoscalerAutoscaleHeadroomAutom
class OceanNpAutoscalerAutoscaleHeadroomAutomatic(dict):
def __init__(__self__, *,
percentage: Optional[int] = None):
- OceanNpAutoscalerAutoscaleHeadroomAutomatic._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- percentage=percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- percentage: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if percentage is not None:
- _setter("percentage", percentage)
+ pulumi.set(__self__, "percentage", percentage)
@property
@pulumi.getter
@@ -2972,27 +2144,10 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
max_memory_gib: Optional[int] = None,
max_vcpu: Optional[int] = None):
- OceanNpAutoscalerResourceLimits._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- max_memory_gib=max_memory_gib,
- max_vcpu=max_vcpu,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- max_memory_gib: Optional[int] = None,
- max_vcpu: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if max_memory_gib is None and 'maxMemoryGib' in kwargs:
- max_memory_gib = kwargs['maxMemoryGib']
- if max_vcpu is None and 'maxVcpu' in kwargs:
- max_vcpu = kwargs['maxVcpu']
-
if max_memory_gib is not None:
- _setter("max_memory_gib", max_memory_gib)
+ pulumi.set(__self__, "max_memory_gib", max_memory_gib)
if max_vcpu is not None:
- _setter("max_vcpu", max_vcpu)
+ pulumi.set(__self__, "max_vcpu", max_vcpu)
@property
@pulumi.getter(name="maxMemoryGib")
@@ -3061,95 +2216,34 @@ def __init__(__self__, *,
min_vcpu: Optional[int] = None,
series: Optional[Sequence[str]] = None,
vm_types: Optional[Sequence[str]] = None):
- OceanNpFilters._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- accelerated_networking=accelerated_networking,
- architectures=architectures,
- disk_performance=disk_performance,
- exclude_series=exclude_series,
- max_gpu=max_gpu,
- max_memory_gib=max_memory_gib,
- max_vcpu=max_vcpu,
- min_data=min_data,
- min_gpu=min_gpu,
- min_memory_gib=min_memory_gib,
- min_nics=min_nics,
- min_vcpu=min_vcpu,
- series=series,
- vm_types=vm_types,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- accelerated_networking: Optional[str] = None,
- architectures: Optional[Sequence[str]] = None,
- disk_performance: Optional[str] = None,
- exclude_series: Optional[Sequence[str]] = None,
- max_gpu: Optional[float] = None,
- max_memory_gib: Optional[float] = None,
- max_vcpu: Optional[int] = None,
- min_data: Optional[int] = None,
- min_gpu: Optional[float] = None,
- min_memory_gib: Optional[float] = None,
- min_nics: Optional[int] = None,
- min_vcpu: Optional[int] = None,
- series: Optional[Sequence[str]] = None,
- vm_types: Optional[Sequence[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if accelerated_networking is None and 'acceleratedNetworking' in kwargs:
- accelerated_networking = kwargs['acceleratedNetworking']
- if disk_performance is None and 'diskPerformance' in kwargs:
- disk_performance = kwargs['diskPerformance']
- if exclude_series is None and 'excludeSeries' in kwargs:
- exclude_series = kwargs['excludeSeries']
- if max_gpu is None and 'maxGpu' in kwargs:
- max_gpu = kwargs['maxGpu']
- if max_memory_gib is None and 'maxMemoryGib' in kwargs:
- max_memory_gib = kwargs['maxMemoryGib']
- if max_vcpu is None and 'maxVcpu' in kwargs:
- max_vcpu = kwargs['maxVcpu']
- if min_data is None and 'minData' in kwargs:
- min_data = kwargs['minData']
- if min_gpu is None and 'minGpu' in kwargs:
- min_gpu = kwargs['minGpu']
- if min_memory_gib is None and 'minMemoryGib' in kwargs:
- min_memory_gib = kwargs['minMemoryGib']
- if min_nics is None and 'minNics' in kwargs:
- min_nics = kwargs['minNics']
- if min_vcpu is None and 'minVcpu' in kwargs:
- min_vcpu = kwargs['minVcpu']
- if vm_types is None and 'vmTypes' in kwargs:
- vm_types = kwargs['vmTypes']
-
if accelerated_networking is not None:
- _setter("accelerated_networking", accelerated_networking)
+ pulumi.set(__self__, "accelerated_networking", accelerated_networking)
if architectures is not None:
- _setter("architectures", architectures)
+ pulumi.set(__self__, "architectures", architectures)
if disk_performance is not None:
- _setter("disk_performance", disk_performance)
+ pulumi.set(__self__, "disk_performance", disk_performance)
if exclude_series is not None:
- _setter("exclude_series", exclude_series)
+ pulumi.set(__self__, "exclude_series", exclude_series)
if max_gpu is not None:
- _setter("max_gpu", max_gpu)
+ pulumi.set(__self__, "max_gpu", max_gpu)
if max_memory_gib is not None:
- _setter("max_memory_gib", max_memory_gib)
+ pulumi.set(__self__, "max_memory_gib", max_memory_gib)
if max_vcpu is not None:
- _setter("max_vcpu", max_vcpu)
+ pulumi.set(__self__, "max_vcpu", max_vcpu)
if min_data is not None:
- _setter("min_data", min_data)
+ pulumi.set(__self__, "min_data", min_data)
if min_gpu is not None:
- _setter("min_gpu", min_gpu)
+ pulumi.set(__self__, "min_gpu", min_gpu)
if min_memory_gib is not None:
- _setter("min_memory_gib", min_memory_gib)
+ pulumi.set(__self__, "min_memory_gib", min_memory_gib)
if min_nics is not None:
- _setter("min_nics", min_nics)
+ pulumi.set(__self__, "min_nics", min_nics)
if min_vcpu is not None:
- _setter("min_vcpu", min_vcpu)
+ pulumi.set(__self__, "min_vcpu", min_vcpu)
if series is not None:
- _setter("series", series)
+ pulumi.set(__self__, "series", series)
if vm_types is not None:
- _setter("vm_types", vm_types)
+ pulumi.set(__self__, "vm_types", vm_types)
@property
@pulumi.getter(name="acceleratedNetworking")
@@ -3252,39 +2346,14 @@ def __init__(__self__, *,
gpu_per_unit: Optional[int] = None,
memory_per_unit: Optional[int] = None,
num_of_units: Optional[int] = None):
- OceanNpHeadroom._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cpu_per_unit=cpu_per_unit,
- gpu_per_unit=gpu_per_unit,
- memory_per_unit=memory_per_unit,
- num_of_units=num_of_units,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cpu_per_unit: Optional[int] = None,
- gpu_per_unit: Optional[int] = None,
- memory_per_unit: Optional[int] = None,
- num_of_units: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cpu_per_unit is None and 'cpuPerUnit' in kwargs:
- cpu_per_unit = kwargs['cpuPerUnit']
- if gpu_per_unit is None and 'gpuPerUnit' in kwargs:
- gpu_per_unit = kwargs['gpuPerUnit']
- if memory_per_unit is None and 'memoryPerUnit' in kwargs:
- memory_per_unit = kwargs['memoryPerUnit']
- if num_of_units is None and 'numOfUnits' in kwargs:
- num_of_units = kwargs['numOfUnits']
-
if cpu_per_unit is not None:
- _setter("cpu_per_unit", cpu_per_unit)
+ pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
if gpu_per_unit is not None:
- _setter("gpu_per_unit", gpu_per_unit)
+ pulumi.set(__self__, "gpu_per_unit", gpu_per_unit)
if memory_per_unit is not None:
- _setter("memory_per_unit", memory_per_unit)
+ pulumi.set(__self__, "memory_per_unit", memory_per_unit)
if num_of_units is not None:
- _setter("num_of_units", num_of_units)
+ pulumi.set(__self__, "num_of_units", num_of_units)
@property
@pulumi.getter(name="cpuPerUnit")
@@ -3328,21 +2397,8 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
grace_period: Optional[int] = None):
- OceanNpHealth._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- grace_period=grace_period,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- grace_period: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if grace_period is None and 'gracePeriod' in kwargs:
- grace_period = kwargs['gracePeriod']
-
if grace_period is not None:
- _setter("grace_period", grace_period)
+ pulumi.set(__self__, "grace_period", grace_period)
@property
@pulumi.getter(name="gracePeriod")
@@ -3371,21 +2427,8 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
shutdown_hours: Optional['outputs.OceanNpSchedulingShutdownHours'] = None):
- OceanNpScheduling._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- shutdown_hours=shutdown_hours,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- shutdown_hours: Optional['outputs.OceanNpSchedulingShutdownHours'] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if shutdown_hours is None and 'shutdownHours' in kwargs:
- shutdown_hours = kwargs['shutdownHours']
-
if shutdown_hours is not None:
- _setter("shutdown_hours", shutdown_hours)
+ pulumi.set(__self__, "shutdown_hours", shutdown_hours)
@property
@pulumi.getter(name="shutdownHours")
@@ -3417,28 +2460,9 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
time_windows: Sequence[str],
is_enabled: Optional[bool] = None):
- OceanNpSchedulingShutdownHours._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- time_windows=time_windows,
- is_enabled=is_enabled,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- time_windows: Optional[Sequence[str]] = None,
- is_enabled: Optional[bool] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if time_windows is None and 'timeWindows' in kwargs:
- time_windows = kwargs['timeWindows']
- if time_windows is None:
- raise TypeError("Missing 'time_windows' argument")
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
-
- _setter("time_windows", time_windows)
+ pulumi.set(__self__, "time_windows", time_windows)
if is_enabled is not None:
- _setter("is_enabled", is_enabled)
+ pulumi.set(__self__, "is_enabled", is_enabled)
@property
@pulumi.getter(name="timeWindows")
@@ -3457,30 +2481,9 @@ def __init__(__self__, *,
effect: str,
key: str,
value: str):
- OceanNpTaint._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- effect=effect,
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- effect: Optional[str] = None,
- key: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if effect is None:
- raise TypeError("Missing 'effect' argument")
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("effect", effect)
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "effect", effect)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -3554,95 +2557,34 @@ def __init__(__self__, *,
min_vcpu: Optional[int] = None,
series: Optional[Sequence[str]] = None,
vm_types: Optional[Sequence[str]] = None):
- OceanNpVirtualNodeGroupFilters._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- accelerated_networking=accelerated_networking,
- architectures=architectures,
- disk_performance=disk_performance,
- exclude_series=exclude_series,
- max_gpu=max_gpu,
- max_memory_gib=max_memory_gib,
- max_vcpu=max_vcpu,
- min_data=min_data,
- min_gpu=min_gpu,
- min_memory_gib=min_memory_gib,
- min_nics=min_nics,
- min_vcpu=min_vcpu,
- series=series,
- vm_types=vm_types,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- accelerated_networking: Optional[str] = None,
- architectures: Optional[Sequence[str]] = None,
- disk_performance: Optional[str] = None,
- exclude_series: Optional[Sequence[str]] = None,
- max_gpu: Optional[float] = None,
- max_memory_gib: Optional[float] = None,
- max_vcpu: Optional[int] = None,
- min_data: Optional[int] = None,
- min_gpu: Optional[float] = None,
- min_memory_gib: Optional[float] = None,
- min_nics: Optional[int] = None,
- min_vcpu: Optional[int] = None,
- series: Optional[Sequence[str]] = None,
- vm_types: Optional[Sequence[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if accelerated_networking is None and 'acceleratedNetworking' in kwargs:
- accelerated_networking = kwargs['acceleratedNetworking']
- if disk_performance is None and 'diskPerformance' in kwargs:
- disk_performance = kwargs['diskPerformance']
- if exclude_series is None and 'excludeSeries' in kwargs:
- exclude_series = kwargs['excludeSeries']
- if max_gpu is None and 'maxGpu' in kwargs:
- max_gpu = kwargs['maxGpu']
- if max_memory_gib is None and 'maxMemoryGib' in kwargs:
- max_memory_gib = kwargs['maxMemoryGib']
- if max_vcpu is None and 'maxVcpu' in kwargs:
- max_vcpu = kwargs['maxVcpu']
- if min_data is None and 'minData' in kwargs:
- min_data = kwargs['minData']
- if min_gpu is None and 'minGpu' in kwargs:
- min_gpu = kwargs['minGpu']
- if min_memory_gib is None and 'minMemoryGib' in kwargs:
- min_memory_gib = kwargs['minMemoryGib']
- if min_nics is None and 'minNics' in kwargs:
- min_nics = kwargs['minNics']
- if min_vcpu is None and 'minVcpu' in kwargs:
- min_vcpu = kwargs['minVcpu']
- if vm_types is None and 'vmTypes' in kwargs:
- vm_types = kwargs['vmTypes']
-
if accelerated_networking is not None:
- _setter("accelerated_networking", accelerated_networking)
+ pulumi.set(__self__, "accelerated_networking", accelerated_networking)
if architectures is not None:
- _setter("architectures", architectures)
+ pulumi.set(__self__, "architectures", architectures)
if disk_performance is not None:
- _setter("disk_performance", disk_performance)
+ pulumi.set(__self__, "disk_performance", disk_performance)
if exclude_series is not None:
- _setter("exclude_series", exclude_series)
+ pulumi.set(__self__, "exclude_series", exclude_series)
if max_gpu is not None:
- _setter("max_gpu", max_gpu)
+ pulumi.set(__self__, "max_gpu", max_gpu)
if max_memory_gib is not None:
- _setter("max_memory_gib", max_memory_gib)
+ pulumi.set(__self__, "max_memory_gib", max_memory_gib)
if max_vcpu is not None:
- _setter("max_vcpu", max_vcpu)
+ pulumi.set(__self__, "max_vcpu", max_vcpu)
if min_data is not None:
- _setter("min_data", min_data)
+ pulumi.set(__self__, "min_data", min_data)
if min_gpu is not None:
- _setter("min_gpu", min_gpu)
+ pulumi.set(__self__, "min_gpu", min_gpu)
if min_memory_gib is not None:
- _setter("min_memory_gib", min_memory_gib)
+ pulumi.set(__self__, "min_memory_gib", min_memory_gib)
if min_nics is not None:
- _setter("min_nics", min_nics)
+ pulumi.set(__self__, "min_nics", min_nics)
if min_vcpu is not None:
- _setter("min_vcpu", min_vcpu)
+ pulumi.set(__self__, "min_vcpu", min_vcpu)
if series is not None:
- _setter("series", series)
+ pulumi.set(__self__, "series", series)
if vm_types is not None:
- _setter("vm_types", vm_types)
+ pulumi.set(__self__, "vm_types", vm_types)
@property
@pulumi.getter(name="acceleratedNetworking")
@@ -3745,39 +2687,14 @@ def __init__(__self__, *,
gpu_per_unit: Optional[int] = None,
memory_per_unit: Optional[int] = None,
num_of_units: Optional[int] = None):
- OceanNpVirtualNodeGroupHeadroom._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cpu_per_unit=cpu_per_unit,
- gpu_per_unit=gpu_per_unit,
- memory_per_unit=memory_per_unit,
- num_of_units=num_of_units,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cpu_per_unit: Optional[int] = None,
- gpu_per_unit: Optional[int] = None,
- memory_per_unit: Optional[int] = None,
- num_of_units: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cpu_per_unit is None and 'cpuPerUnit' in kwargs:
- cpu_per_unit = kwargs['cpuPerUnit']
- if gpu_per_unit is None and 'gpuPerUnit' in kwargs:
- gpu_per_unit = kwargs['gpuPerUnit']
- if memory_per_unit is None and 'memoryPerUnit' in kwargs:
- memory_per_unit = kwargs['memoryPerUnit']
- if num_of_units is None and 'numOfUnits' in kwargs:
- num_of_units = kwargs['numOfUnits']
-
if cpu_per_unit is not None:
- _setter("cpu_per_unit", cpu_per_unit)
+ pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
if gpu_per_unit is not None:
- _setter("gpu_per_unit", gpu_per_unit)
+ pulumi.set(__self__, "gpu_per_unit", gpu_per_unit)
if memory_per_unit is not None:
- _setter("memory_per_unit", memory_per_unit)
+ pulumi.set(__self__, "memory_per_unit", memory_per_unit)
if num_of_units is not None:
- _setter("num_of_units", num_of_units)
+ pulumi.set(__self__, "num_of_units", num_of_units)
@property
@pulumi.getter(name="cpuPerUnit")
@@ -3806,30 +2723,9 @@ def __init__(__self__, *,
effect: str,
key: str,
value: str):
- OceanNpVirtualNodeGroupTaint._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- effect=effect,
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- effect: Optional[str] = None,
- key: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if effect is None:
- raise TypeError("Missing 'effect' argument")
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("effect", effect)
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "effect", effect)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -3873,26 +2769,9 @@ def __init__(__self__, *,
:param int size_gb: The size of the OS disk in GB.
:param str type: The type of load balancer. Supported value: `loadBalancer`
"""
- OceanOsDisk._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- size_gb=size_gb,
- type=type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- size_gb: Optional[int] = None,
- type: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if size_gb is None and 'sizeGb' in kwargs:
- size_gb = kwargs['sizeGb']
- if size_gb is None:
- raise TypeError("Missing 'size_gb' argument")
-
- _setter("size_gb", size_gb)
+ pulumi.set(__self__, "size_gb", size_gb)
if type is not None:
- _setter("type", type)
+ pulumi.set(__self__, "type", type)
@property
@pulumi.getter(name="sizeGb")
@@ -3939,27 +2818,10 @@ def __init__(__self__, *,
:param bool fallback_to_ondemand: If no spot instance markets are available, enable Ocean to launch on-demand instances instead.
:param int spot_percentage: Percentage of Spot VMs to maintain.
"""
- OceanStrategy._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- fallback_to_ondemand=fallback_to_ondemand,
- spot_percentage=spot_percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- fallback_to_ondemand: Optional[bool] = None,
- spot_percentage: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if fallback_to_ondemand is None and 'fallbackToOndemand' in kwargs:
- fallback_to_ondemand = kwargs['fallbackToOndemand']
- if spot_percentage is None and 'spotPercentage' in kwargs:
- spot_percentage = kwargs['spotPercentage']
-
if fallback_to_ondemand is not None:
- _setter("fallback_to_ondemand", fallback_to_ondemand)
+ pulumi.set(__self__, "fallback_to_ondemand", fallback_to_ondemand)
if spot_percentage is not None:
- _setter("spot_percentage", spot_percentage)
+ pulumi.set(__self__, "spot_percentage", spot_percentage)
@property
@pulumi.getter(name="fallbackToOndemand")
@@ -3987,23 +2849,10 @@ def __init__(__self__, *,
:param str key: Tag key.
:param str value: Tag value.
"""
- OceanTag._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if key is not None:
- _setter("key", key)
+ pulumi.set(__self__, "key", key)
if value is not None:
- _setter("value", value)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -4049,27 +2898,10 @@ def __init__(__self__, *,
"""
:param int auto_headroom_percentage: Number between 0-200 to control the headroom % of the specific Virtual Node Group. Effective when `cluster.autoScaler.headroom.automatic.is_enabled` = true is set on the Ocean cluster.
"""
- OceanVirtualNodeGroupAutoscale._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- auto_headroom_percentage=auto_headroom_percentage,
- autoscale_headrooms=autoscale_headrooms,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- auto_headroom_percentage: Optional[int] = None,
- autoscale_headrooms: Optional[Sequence['outputs.OceanVirtualNodeGroupAutoscaleAutoscaleHeadroom']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if auto_headroom_percentage is None and 'autoHeadroomPercentage' in kwargs:
- auto_headroom_percentage = kwargs['autoHeadroomPercentage']
- if autoscale_headrooms is None and 'autoscaleHeadrooms' in kwargs:
- autoscale_headrooms = kwargs['autoscaleHeadrooms']
-
if auto_headroom_percentage is not None:
- _setter("auto_headroom_percentage", auto_headroom_percentage)
+ pulumi.set(__self__, "auto_headroom_percentage", auto_headroom_percentage)
if autoscale_headrooms is not None:
- _setter("autoscale_headrooms", autoscale_headrooms)
+ pulumi.set(__self__, "autoscale_headrooms", autoscale_headrooms)
@property
@pulumi.getter(name="autoHeadroomPercentage")
@@ -4121,40 +2953,13 @@ def __init__(__self__, *,
:param int gpu_per_unit: How many GPU cores should be allocated for headroom unit.
:param int memory_per_unit: Configure the amount of memory (MiB) to allocate the headroom.
"""
- OceanVirtualNodeGroupAutoscaleAutoscaleHeadroom._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- num_of_units=num_of_units,
- cpu_per_unit=cpu_per_unit,
- gpu_per_unit=gpu_per_unit,
- memory_per_unit=memory_per_unit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- num_of_units: Optional[int] = None,
- cpu_per_unit: Optional[int] = None,
- gpu_per_unit: Optional[int] = None,
- memory_per_unit: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if num_of_units is None and 'numOfUnits' in kwargs:
- num_of_units = kwargs['numOfUnits']
- if num_of_units is None:
- raise TypeError("Missing 'num_of_units' argument")
- if cpu_per_unit is None and 'cpuPerUnit' in kwargs:
- cpu_per_unit = kwargs['cpuPerUnit']
- if gpu_per_unit is None and 'gpuPerUnit' in kwargs:
- gpu_per_unit = kwargs['gpuPerUnit']
- if memory_per_unit is None and 'memoryPerUnit' in kwargs:
- memory_per_unit = kwargs['memoryPerUnit']
-
- _setter("num_of_units", num_of_units)
+ pulumi.set(__self__, "num_of_units", num_of_units)
if cpu_per_unit is not None:
- _setter("cpu_per_unit", cpu_per_unit)
+ pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
if gpu_per_unit is not None:
- _setter("gpu_per_unit", gpu_per_unit)
+ pulumi.set(__self__, "gpu_per_unit", gpu_per_unit)
if memory_per_unit is not None:
- _setter("memory_per_unit", memory_per_unit)
+ pulumi.set(__self__, "memory_per_unit", memory_per_unit)
@property
@pulumi.getter(name="numOfUnits")
@@ -4198,24 +3003,9 @@ def __init__(__self__, *,
:param str key: Tag Key for Vms in the cluster.
:param str value: Tag Value for VMs in the cluster.
"""
- OceanVirtualNodeGroupLabel._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
-
- _setter("key", key)
+ pulumi.set(__self__, "key", key)
if value is not None:
- _setter("value", value)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -4264,31 +3054,12 @@ def __init__(__self__, *,
:param 'OceanVirtualNodeGroupLaunchSpecificationOsDiskArgs' os_disk: Specify OS disk specification other than default.
:param Sequence['OceanVirtualNodeGroupLaunchSpecificationTagArgs'] tags: Additional key-value pairs to be used to tag the VMs in the virtual node group.
"""
- OceanVirtualNodeGroupLaunchSpecification._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- max_pods=max_pods,
- os_disk=os_disk,
- tags=tags,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- max_pods: Optional[int] = None,
- os_disk: Optional['outputs.OceanVirtualNodeGroupLaunchSpecificationOsDisk'] = None,
- tags: Optional[Sequence['outputs.OceanVirtualNodeGroupLaunchSpecificationTag']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if max_pods is None and 'maxPods' in kwargs:
- max_pods = kwargs['maxPods']
- if os_disk is None and 'osDisk' in kwargs:
- os_disk = kwargs['osDisk']
-
if max_pods is not None:
- _setter("max_pods", max_pods)
+ pulumi.set(__self__, "max_pods", max_pods)
if os_disk is not None:
- _setter("os_disk", os_disk)
+ pulumi.set(__self__, "os_disk", os_disk)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
@property
@pulumi.getter(name="maxPods")
@@ -4345,32 +3116,11 @@ def __init__(__self__, *,
:param str type: The type of the OS disk. Valid values: `"Standard_LRS"`, `"Premium_LRS"`, `"StandardSSD_LRS"`.
:param bool utilize_ephemeral_storage: Flag to enable/disable the Ephemeral OS Disk utilization.
"""
- OceanVirtualNodeGroupLaunchSpecificationOsDisk._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- size_gb=size_gb,
- type=type,
- utilize_ephemeral_storage=utilize_ephemeral_storage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- size_gb: Optional[int] = None,
- type: Optional[str] = None,
- utilize_ephemeral_storage: Optional[bool] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if size_gb is None and 'sizeGb' in kwargs:
- size_gb = kwargs['sizeGb']
- if size_gb is None:
- raise TypeError("Missing 'size_gb' argument")
- if utilize_ephemeral_storage is None and 'utilizeEphemeralStorage' in kwargs:
- utilize_ephemeral_storage = kwargs['utilizeEphemeralStorage']
-
- _setter("size_gb", size_gb)
+ pulumi.set(__self__, "size_gb", size_gb)
if type is not None:
- _setter("type", type)
+ pulumi.set(__self__, "type", type)
if utilize_ephemeral_storage is not None:
- _setter("utilize_ephemeral_storage", utilize_ephemeral_storage)
+ pulumi.set(__self__, "utilize_ephemeral_storage", utilize_ephemeral_storage)
@property
@pulumi.getter(name="sizeGb")
@@ -4406,23 +3156,10 @@ def __init__(__self__, *,
:param str key: Tag Key for Vms in the cluster.
:param str value: Tag Value for VMs in the cluster.
"""
- OceanVirtualNodeGroupLaunchSpecificationTag._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if key is not None:
- _setter("key", key)
+ pulumi.set(__self__, "key", key)
if value is not None:
- _setter("value", value)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -4465,21 +3202,8 @@ def __init__(__self__, *,
"""
:param int max_instance_count: Option to set a maximum number of instances per virtual node group. If set, value must be greater than or equal to 0.
"""
- OceanVirtualNodeGroupResourceLimit._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- max_instance_count=max_instance_count,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- max_instance_count: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if max_instance_count is None and 'maxInstanceCount' in kwargs:
- max_instance_count = kwargs['maxInstanceCount']
-
if max_instance_count is not None:
- _setter("max_instance_count", max_instance_count)
+ pulumi.set(__self__, "max_instance_count", max_instance_count)
@property
@pulumi.getter(name="maxInstanceCount")
@@ -4501,30 +3225,9 @@ def __init__(__self__, *,
:param str key: Tag Key for Vms in the cluster.
:param str value: Tag Value for VMs in the cluster.
"""
- OceanVirtualNodeGroupTaint._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- effect=effect,
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- effect: Optional[str] = None,
- key: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if effect is None:
- raise TypeError("Missing 'effect' argument")
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("effect", effect)
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "effect", effect)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -4558,19 +3261,8 @@ def __init__(__self__, *,
"""
:param Sequence[str] whitelists: VM types allowed in the Ocean cluster.
"""
- OceanVmSize._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- whitelists=whitelists,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- whitelists: Optional[Sequence[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if whitelists is not None:
- _setter("whitelists", whitelists)
+ pulumi.set(__self__, "whitelists", whitelists)
@property
@pulumi.getter
diff --git a/sdk/python/pulumi_spotinst/config/__init__.pyi b/sdk/python/pulumi_spotinst/config/__init__.pyi
index 69aff493..5a682ef7 100644
--- a/sdk/python/pulumi_spotinst/config/__init__.pyi
+++ b/sdk/python/pulumi_spotinst/config/__init__.pyi
@@ -6,7 +6,7 @@ import copy
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
account: Optional[str]
diff --git a/sdk/python/pulumi_spotinst/config/vars.py b/sdk/python/pulumi_spotinst/config/vars.py
index 82e40a6b..cc72aaef 100644
--- a/sdk/python/pulumi_spotinst/config/vars.py
+++ b/sdk/python/pulumi_spotinst/config/vars.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
import types
diff --git a/sdk/python/pulumi_spotinst/data_integration.py b/sdk/python/pulumi_spotinst/data_integration.py
index ba3f1392..ebc9d42b 100644
--- a/sdk/python/pulumi_spotinst/data_integration.py
+++ b/sdk/python/pulumi_spotinst/data_integration.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from . import _utilities
from . import outputs
from ._inputs import *
@@ -25,27 +25,12 @@ def __init__(__self__, *,
:param pulumi.Input['DataIntegrationS3Args'] s3: When vendor value is s3, the following fields are included:
:param pulumi.Input[str] status: Determines if this data integration is on or off. Valid values: `"enabled"`, `"disabled"`
"""
- DataIntegrationArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- s3=s3,
- status=status,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- s3: Optional[pulumi.Input['DataIntegrationS3Args']] = None,
- status: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if s3 is not None:
- _setter("s3", s3)
+ pulumi.set(__self__, "s3", s3)
if status is not None:
- _setter("status", status)
+ pulumi.set(__self__, "status", status)
@property
@pulumi.getter
@@ -96,27 +81,12 @@ def __init__(__self__, *,
:param pulumi.Input['DataIntegrationS3Args'] s3: When vendor value is s3, the following fields are included:
:param pulumi.Input[str] status: Determines if this data integration is on or off. Valid values: `"enabled"`, `"disabled"`
"""
- _DataIntegrationState._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- s3=s3,
- status=status,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- s3: Optional[pulumi.Input['DataIntegrationS3Args']] = None,
- status: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if s3 is not None:
- _setter("s3", s3)
+ pulumi.set(__self__, "s3", s3)
if status is not None:
- _setter("status", status)
+ pulumi.set(__self__, "status", status)
@property
@pulumi.getter
@@ -220,10 +190,6 @@ def __init__(__self__, resource_name: str, *args, **kwargs):
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
- kwargs = kwargs or {}
- def _setter(key, value):
- kwargs[key] = value
- DataIntegrationArgs._configure(_setter, **kwargs)
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
@@ -242,7 +208,6 @@ def _internal_init(__self__,
__props__ = DataIntegrationArgs.__new__(DataIntegrationArgs)
__props__.__dict__["name"] = name
- s3 = _utilities.configure(s3, DataIntegrationS3Args, True)
__props__.__dict__["s3"] = s3
__props__.__dict__["status"] = status
super(DataIntegration, __self__).__init__(
diff --git a/sdk/python/pulumi_spotinst/ecs/_inputs.py b/sdk/python/pulumi_spotinst/ecs/_inputs.py
index d448d226..8109f15b 100644
--- a/sdk/python/pulumi_spotinst/ecs/_inputs.py
+++ b/sdk/python/pulumi_spotinst/ecs/_inputs.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
__all__ = [
@@ -69,63 +69,24 @@ def __init__(__self__, *,
:param pulumi.Input['OceanAutoscalerResourceLimitsArgs'] resource_limits: Optionally set upper and lower bounds on the resource usage of the cluster.
:param pulumi.Input[bool] should_scale_down_non_service_tasks: Option to scale down non-service tasks. If not set, Ocean does not scale down standalone tasks.
"""
- OceanAutoscalerArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- auto_headroom_percentage=auto_headroom_percentage,
- cooldown=cooldown,
- down=down,
- enable_automatic_and_manual_headroom=enable_automatic_and_manual_headroom,
- headroom=headroom,
- is_auto_config=is_auto_config,
- is_enabled=is_enabled,
- resource_limits=resource_limits,
- should_scale_down_non_service_tasks=should_scale_down_non_service_tasks,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- auto_headroom_percentage: Optional[pulumi.Input[int]] = None,
- cooldown: Optional[pulumi.Input[int]] = None,
- down: Optional[pulumi.Input['OceanAutoscalerDownArgs']] = None,
- enable_automatic_and_manual_headroom: Optional[pulumi.Input[bool]] = None,
- headroom: Optional[pulumi.Input['OceanAutoscalerHeadroomArgs']] = None,
- is_auto_config: Optional[pulumi.Input[bool]] = None,
- is_enabled: Optional[pulumi.Input[bool]] = None,
- resource_limits: Optional[pulumi.Input['OceanAutoscalerResourceLimitsArgs']] = None,
- should_scale_down_non_service_tasks: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if auto_headroom_percentage is None and 'autoHeadroomPercentage' in kwargs:
- auto_headroom_percentage = kwargs['autoHeadroomPercentage']
- if enable_automatic_and_manual_headroom is None and 'enableAutomaticAndManualHeadroom' in kwargs:
- enable_automatic_and_manual_headroom = kwargs['enableAutomaticAndManualHeadroom']
- if is_auto_config is None and 'isAutoConfig' in kwargs:
- is_auto_config = kwargs['isAutoConfig']
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
- if resource_limits is None and 'resourceLimits' in kwargs:
- resource_limits = kwargs['resourceLimits']
- if should_scale_down_non_service_tasks is None and 'shouldScaleDownNonServiceTasks' in kwargs:
- should_scale_down_non_service_tasks = kwargs['shouldScaleDownNonServiceTasks']
-
if auto_headroom_percentage is not None:
- _setter("auto_headroom_percentage", auto_headroom_percentage)
+ pulumi.set(__self__, "auto_headroom_percentage", auto_headroom_percentage)
if cooldown is not None:
- _setter("cooldown", cooldown)
+ pulumi.set(__self__, "cooldown", cooldown)
if down is not None:
- _setter("down", down)
+ pulumi.set(__self__, "down", down)
if enable_automatic_and_manual_headroom is not None:
- _setter("enable_automatic_and_manual_headroom", enable_automatic_and_manual_headroom)
+ pulumi.set(__self__, "enable_automatic_and_manual_headroom", enable_automatic_and_manual_headroom)
if headroom is not None:
- _setter("headroom", headroom)
+ pulumi.set(__self__, "headroom", headroom)
if is_auto_config is not None:
- _setter("is_auto_config", is_auto_config)
+ pulumi.set(__self__, "is_auto_config", is_auto_config)
if is_enabled is not None:
- _setter("is_enabled", is_enabled)
+ pulumi.set(__self__, "is_enabled", is_enabled)
if resource_limits is not None:
- _setter("resource_limits", resource_limits)
+ pulumi.set(__self__, "resource_limits", resource_limits)
if should_scale_down_non_service_tasks is not None:
- _setter("should_scale_down_non_service_tasks", should_scale_down_non_service_tasks)
+ pulumi.set(__self__, "should_scale_down_non_service_tasks", should_scale_down_non_service_tasks)
@property
@pulumi.getter(name="autoHeadroomPercentage")
@@ -247,21 +208,8 @@ def __init__(__self__, *,
"""
:param pulumi.Input[float] max_scale_down_percentage: Would represent the maximum % to scale-down. Number between 1-100.
"""
- OceanAutoscalerDownArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- max_scale_down_percentage=max_scale_down_percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- max_scale_down_percentage: Optional[pulumi.Input[float]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if max_scale_down_percentage is None and 'maxScaleDownPercentage' in kwargs:
- max_scale_down_percentage = kwargs['maxScaleDownPercentage']
-
if max_scale_down_percentage is not None:
- _setter("max_scale_down_percentage", max_scale_down_percentage)
+ pulumi.set(__self__, "max_scale_down_percentage", max_scale_down_percentage)
@property
@pulumi.getter(name="maxScaleDownPercentage")
@@ -287,33 +235,12 @@ def __init__(__self__, *,
:param pulumi.Input[int] memory_per_unit: Optionally configure the amount of memory (MB) to allocate the headroom.
:param pulumi.Input[int] num_of_units: The number of units to retain as headroom, where each unit has the defined headroom CPU and memory.
"""
- OceanAutoscalerHeadroomArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cpu_per_unit=cpu_per_unit,
- memory_per_unit=memory_per_unit,
- num_of_units=num_of_units,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cpu_per_unit: Optional[pulumi.Input[int]] = None,
- memory_per_unit: Optional[pulumi.Input[int]] = None,
- num_of_units: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cpu_per_unit is None and 'cpuPerUnit' in kwargs:
- cpu_per_unit = kwargs['cpuPerUnit']
- if memory_per_unit is None and 'memoryPerUnit' in kwargs:
- memory_per_unit = kwargs['memoryPerUnit']
- if num_of_units is None and 'numOfUnits' in kwargs:
- num_of_units = kwargs['numOfUnits']
-
if cpu_per_unit is not None:
- _setter("cpu_per_unit", cpu_per_unit)
+ pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
if memory_per_unit is not None:
- _setter("memory_per_unit", memory_per_unit)
+ pulumi.set(__self__, "memory_per_unit", memory_per_unit)
if num_of_units is not None:
- _setter("num_of_units", num_of_units)
+ pulumi.set(__self__, "num_of_units", num_of_units)
@property
@pulumi.getter(name="cpuPerUnit")
@@ -361,27 +288,10 @@ def __init__(__self__, *,
:param pulumi.Input[int] max_memory_gib: Maximum amount of Memory (GiB).
:param pulumi.Input[int] max_vcpu: Maximum number of vcpus available.
"""
- OceanAutoscalerResourceLimitsArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- max_memory_gib=max_memory_gib,
- max_vcpu=max_vcpu,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- max_memory_gib: Optional[pulumi.Input[int]] = None,
- max_vcpu: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if max_memory_gib is None and 'maxMemoryGib' in kwargs:
- max_memory_gib = kwargs['maxMemoryGib']
- if max_vcpu is None and 'maxVcpu' in kwargs:
- max_vcpu = kwargs['maxVcpu']
-
if max_memory_gib is not None:
- _setter("max_memory_gib", max_memory_gib)
+ pulumi.set(__self__, "max_memory_gib", max_memory_gib)
if max_vcpu is not None:
- _setter("max_vcpu", max_vcpu)
+ pulumi.set(__self__, "max_vcpu", max_vcpu)
@property
@pulumi.getter(name="maxMemoryGib")
@@ -420,38 +330,13 @@ def __init__(__self__, *,
:param pulumi.Input['OceanBlockDeviceMappingEbsArgs'] ebs: Object. Set Elastic Block Store properties.
:param pulumi.Input[str] no_device: String. Suppresses the specified device included in the block device mapping of the AMI.
"""
- OceanBlockDeviceMappingArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- device_name=device_name,
- ebs=ebs,
- no_device=no_device,
- virtual_name=virtual_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- device_name: Optional[pulumi.Input[str]] = None,
- ebs: Optional[pulumi.Input['OceanBlockDeviceMappingEbsArgs']] = None,
- no_device: Optional[pulumi.Input[str]] = None,
- virtual_name: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if device_name is None and 'deviceName' in kwargs:
- device_name = kwargs['deviceName']
- if device_name is None:
- raise TypeError("Missing 'device_name' argument")
- if no_device is None and 'noDevice' in kwargs:
- no_device = kwargs['noDevice']
- if virtual_name is None and 'virtualName' in kwargs:
- virtual_name = kwargs['virtualName']
-
- _setter("device_name", device_name)
+ pulumi.set(__self__, "device_name", device_name)
if ebs is not None:
- _setter("ebs", ebs)
+ pulumi.set(__self__, "ebs", ebs)
if no_device is not None:
- _setter("no_device", no_device)
+ pulumi.set(__self__, "no_device", no_device)
if virtual_name is not None:
- _setter("virtual_name", virtual_name)
+ pulumi.set(__self__, "virtual_name", virtual_name)
@property
@pulumi.getter(name="deviceName")
@@ -522,63 +407,24 @@ def __init__(__self__, *,
:param pulumi.Input[int] volume_size: Int. The size (in GB) of the volume.
:param pulumi.Input[str] volume_type: String. The type of the volume. Example: `gp2`.
"""
- OceanBlockDeviceMappingEbsArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- delete_on_termination=delete_on_termination,
- dynamic_volume_size=dynamic_volume_size,
- encrypted=encrypted,
- iops=iops,
- kms_key_id=kms_key_id,
- snapshot_id=snapshot_id,
- throughput=throughput,
- volume_size=volume_size,
- volume_type=volume_type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- delete_on_termination: Optional[pulumi.Input[bool]] = None,
- dynamic_volume_size: Optional[pulumi.Input['OceanBlockDeviceMappingEbsDynamicVolumeSizeArgs']] = None,
- encrypted: Optional[pulumi.Input[bool]] = None,
- iops: Optional[pulumi.Input[int]] = None,
- kms_key_id: Optional[pulumi.Input[str]] = None,
- snapshot_id: Optional[pulumi.Input[str]] = None,
- throughput: Optional[pulumi.Input[int]] = None,
- volume_size: Optional[pulumi.Input[int]] = None,
- volume_type: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if delete_on_termination is None and 'deleteOnTermination' in kwargs:
- delete_on_termination = kwargs['deleteOnTermination']
- if dynamic_volume_size is None and 'dynamicVolumeSize' in kwargs:
- dynamic_volume_size = kwargs['dynamicVolumeSize']
- if kms_key_id is None and 'kmsKeyId' in kwargs:
- kms_key_id = kwargs['kmsKeyId']
- if snapshot_id is None and 'snapshotId' in kwargs:
- snapshot_id = kwargs['snapshotId']
- if volume_size is None and 'volumeSize' in kwargs:
- volume_size = kwargs['volumeSize']
- if volume_type is None and 'volumeType' in kwargs:
- volume_type = kwargs['volumeType']
-
if delete_on_termination is not None:
- _setter("delete_on_termination", delete_on_termination)
+ pulumi.set(__self__, "delete_on_termination", delete_on_termination)
if dynamic_volume_size is not None:
- _setter("dynamic_volume_size", dynamic_volume_size)
+ pulumi.set(__self__, "dynamic_volume_size", dynamic_volume_size)
if encrypted is not None:
- _setter("encrypted", encrypted)
+ pulumi.set(__self__, "encrypted", encrypted)
if iops is not None:
- _setter("iops", iops)
+ pulumi.set(__self__, "iops", iops)
if kms_key_id is not None:
- _setter("kms_key_id", kms_key_id)
+ pulumi.set(__self__, "kms_key_id", kms_key_id)
if snapshot_id is not None:
- _setter("snapshot_id", snapshot_id)
+ pulumi.set(__self__, "snapshot_id", snapshot_id)
if throughput is not None:
- _setter("throughput", throughput)
+ pulumi.set(__self__, "throughput", throughput)
if volume_size is not None:
- _setter("volume_size", volume_size)
+ pulumi.set(__self__, "volume_size", volume_size)
if volume_type is not None:
- _setter("volume_type", volume_type)
+ pulumi.set(__self__, "volume_type", volume_type)
@property
@pulumi.getter(name="deleteOnTermination")
@@ -700,34 +546,9 @@ def __init__(__self__, *,
:param pulumi.Input[str] resource: String. Resource type to increase volume size dynamically by. Valid values: `CPU`.
:param pulumi.Input[int] size_per_resource_unit: Int. Additional size (in GB) per resource unit. Example: When the `baseSize=50`, `sizePerResourceUnit=20`, and instance with two CPUs is launched, its total disk size will be: 90GB.
"""
- OceanBlockDeviceMappingEbsDynamicVolumeSizeArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- base_size=base_size,
- resource=resource,
- size_per_resource_unit=size_per_resource_unit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- base_size: Optional[pulumi.Input[int]] = None,
- resource: Optional[pulumi.Input[str]] = None,
- size_per_resource_unit: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if base_size is None and 'baseSize' in kwargs:
- base_size = kwargs['baseSize']
- if base_size is None:
- raise TypeError("Missing 'base_size' argument")
- if resource is None:
- raise TypeError("Missing 'resource' argument")
- if size_per_resource_unit is None and 'sizePerResourceUnit' in kwargs:
- size_per_resource_unit = kwargs['sizePerResourceUnit']
- if size_per_resource_unit is None:
- raise TypeError("Missing 'size_per_resource_unit' argument")
-
- _setter("base_size", base_size)
- _setter("resource", resource)
- _setter("size_per_resource_unit", size_per_resource_unit)
+ pulumi.set(__self__, "base_size", base_size)
+ pulumi.set(__self__, "resource", resource)
+ pulumi.set(__self__, "size_per_resource_unit", size_per_resource_unit)
@property
@pulumi.getter(name="baseSize")
@@ -773,21 +594,8 @@ def __init__(__self__, *,
"""
:param pulumi.Input[str] availability_vs_cost: You can control the approach that Ocean takes while launching nodes by configuring this value. Possible values: `costOriented`,`balanced`,`cheapest`.
"""
- OceanClusterOrientationArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- availability_vs_cost=availability_vs_cost,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- availability_vs_cost: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if availability_vs_cost is None and 'availabilityVsCost' in kwargs:
- availability_vs_cost = kwargs['availabilityVsCost']
-
if availability_vs_cost is not None:
- _setter("availability_vs_cost", availability_vs_cost)
+ pulumi.set(__self__, "availability_vs_cost", availability_vs_cost)
@property
@pulumi.getter(name="availabilityVsCost")
@@ -845,123 +653,44 @@ def __init__(__self__, *,
:param pulumi.Input[Sequence[pulumi.Input[str]]] root_device_types: The filtered instance types will have a root device types from this list.
:param pulumi.Input[Sequence[pulumi.Input[str]]] virtualization_types: The filtered instance types will support at least one of the virtualization types from this list.
"""
- OceanFiltersArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- architectures=architectures,
- categories=categories,
- disk_types=disk_types,
- exclude_families=exclude_families,
- exclude_metal=exclude_metal,
- hypervisors=hypervisors,
- include_families=include_families,
- is_ena_supported=is_ena_supported,
- max_gpu=max_gpu,
- max_memory_gib=max_memory_gib,
- max_network_performance=max_network_performance,
- max_vcpu=max_vcpu,
- min_enis=min_enis,
- min_gpu=min_gpu,
- min_memory_gib=min_memory_gib,
- min_network_performance=min_network_performance,
- min_vcpu=min_vcpu,
- root_device_types=root_device_types,
- virtualization_types=virtualization_types,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- architectures: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- categories: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- disk_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- exclude_families: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- exclude_metal: Optional[pulumi.Input[bool]] = None,
- hypervisors: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- include_families: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- is_ena_supported: Optional[pulumi.Input[str]] = None,
- max_gpu: Optional[pulumi.Input[int]] = None,
- max_memory_gib: Optional[pulumi.Input[float]] = None,
- max_network_performance: Optional[pulumi.Input[int]] = None,
- max_vcpu: Optional[pulumi.Input[int]] = None,
- min_enis: Optional[pulumi.Input[int]] = None,
- min_gpu: Optional[pulumi.Input[int]] = None,
- min_memory_gib: Optional[pulumi.Input[float]] = None,
- min_network_performance: Optional[pulumi.Input[int]] = None,
- min_vcpu: Optional[pulumi.Input[int]] = None,
- root_device_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- virtualization_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if disk_types is None and 'diskTypes' in kwargs:
- disk_types = kwargs['diskTypes']
- if exclude_families is None and 'excludeFamilies' in kwargs:
- exclude_families = kwargs['excludeFamilies']
- if exclude_metal is None and 'excludeMetal' in kwargs:
- exclude_metal = kwargs['excludeMetal']
- if include_families is None and 'includeFamilies' in kwargs:
- include_families = kwargs['includeFamilies']
- if is_ena_supported is None and 'isEnaSupported' in kwargs:
- is_ena_supported = kwargs['isEnaSupported']
- if max_gpu is None and 'maxGpu' in kwargs:
- max_gpu = kwargs['maxGpu']
- if max_memory_gib is None and 'maxMemoryGib' in kwargs:
- max_memory_gib = kwargs['maxMemoryGib']
- if max_network_performance is None and 'maxNetworkPerformance' in kwargs:
- max_network_performance = kwargs['maxNetworkPerformance']
- if max_vcpu is None and 'maxVcpu' in kwargs:
- max_vcpu = kwargs['maxVcpu']
- if min_enis is None and 'minEnis' in kwargs:
- min_enis = kwargs['minEnis']
- if min_gpu is None and 'minGpu' in kwargs:
- min_gpu = kwargs['minGpu']
- if min_memory_gib is None and 'minMemoryGib' in kwargs:
- min_memory_gib = kwargs['minMemoryGib']
- if min_network_performance is None and 'minNetworkPerformance' in kwargs:
- min_network_performance = kwargs['minNetworkPerformance']
- if min_vcpu is None and 'minVcpu' in kwargs:
- min_vcpu = kwargs['minVcpu']
- if root_device_types is None and 'rootDeviceTypes' in kwargs:
- root_device_types = kwargs['rootDeviceTypes']
- if virtualization_types is None and 'virtualizationTypes' in kwargs:
- virtualization_types = kwargs['virtualizationTypes']
-
if architectures is not None:
- _setter("architectures", architectures)
+ pulumi.set(__self__, "architectures", architectures)
if categories is not None:
- _setter("categories", categories)
+ pulumi.set(__self__, "categories", categories)
if disk_types is not None:
- _setter("disk_types", disk_types)
+ pulumi.set(__self__, "disk_types", disk_types)
if exclude_families is not None:
- _setter("exclude_families", exclude_families)
+ pulumi.set(__self__, "exclude_families", exclude_families)
if exclude_metal is not None:
- _setter("exclude_metal", exclude_metal)
+ pulumi.set(__self__, "exclude_metal", exclude_metal)
if hypervisors is not None:
- _setter("hypervisors", hypervisors)
+ pulumi.set(__self__, "hypervisors", hypervisors)
if include_families is not None:
- _setter("include_families", include_families)
+ pulumi.set(__self__, "include_families", include_families)
if is_ena_supported is not None:
- _setter("is_ena_supported", is_ena_supported)
+ pulumi.set(__self__, "is_ena_supported", is_ena_supported)
if max_gpu is not None:
- _setter("max_gpu", max_gpu)
+ pulumi.set(__self__, "max_gpu", max_gpu)
if max_memory_gib is not None:
- _setter("max_memory_gib", max_memory_gib)
+ pulumi.set(__self__, "max_memory_gib", max_memory_gib)
if max_network_performance is not None:
- _setter("max_network_performance", max_network_performance)
+ pulumi.set(__self__, "max_network_performance", max_network_performance)
if max_vcpu is not None:
- _setter("max_vcpu", max_vcpu)
+ pulumi.set(__self__, "max_vcpu", max_vcpu)
if min_enis is not None:
- _setter("min_enis", min_enis)
+ pulumi.set(__self__, "min_enis", min_enis)
if min_gpu is not None:
- _setter("min_gpu", min_gpu)
+ pulumi.set(__self__, "min_gpu", min_gpu)
if min_memory_gib is not None:
- _setter("min_memory_gib", min_memory_gib)
+ pulumi.set(__self__, "min_memory_gib", min_memory_gib)
if min_network_performance is not None:
- _setter("min_network_performance", min_network_performance)
+ pulumi.set(__self__, "min_network_performance", min_network_performance)
if min_vcpu is not None:
- _setter("min_vcpu", min_vcpu)
+ pulumi.set(__self__, "min_vcpu", min_vcpu)
if root_device_types is not None:
- _setter("root_device_types", root_device_types)
+ pulumi.set(__self__, "root_device_types", root_device_types)
if virtualization_types is not None:
- _setter("virtualization_types", virtualization_types)
+ pulumi.set(__self__, "virtualization_types", virtualization_types)
@property
@pulumi.getter
@@ -1201,28 +930,9 @@ def __init__(__self__, *,
:param pulumi.Input[str] http_tokens: Determines if a signed token is required or not. Valid values: `optional` or `required`.
:param pulumi.Input[int] http_put_response_hop_limit: An integer from 1 through 64. The desired HTTP PUT response hop limit for instance metadata requests. The larger the number, the further the instance metadata requests can travel.
"""
- OceanInstanceMetadataOptionsArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- http_tokens=http_tokens,
- http_put_response_hop_limit=http_put_response_hop_limit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- http_tokens: Optional[pulumi.Input[str]] = None,
- http_put_response_hop_limit: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if http_tokens is None and 'httpTokens' in kwargs:
- http_tokens = kwargs['httpTokens']
- if http_tokens is None:
- raise TypeError("Missing 'http_tokens' argument")
- if http_put_response_hop_limit is None and 'httpPutResponseHopLimit' in kwargs:
- http_put_response_hop_limit = kwargs['httpPutResponseHopLimit']
-
- _setter("http_tokens", http_tokens)
+ pulumi.set(__self__, "http_tokens", http_tokens)
if http_put_response_hop_limit is not None:
- _setter("http_put_response_hop_limit", http_put_response_hop_limit)
+ pulumi.set(__self__, "http_put_response_hop_limit", http_put_response_hop_limit)
@property
@pulumi.getter(name="httpTokens")
@@ -1258,25 +968,8 @@ def __init__(__self__, *,
:param pulumi.Input[str] key: The label key.
:param pulumi.Input[str] value: The label value.
"""
- OceanLaunchSpecAttributeArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -1314,34 +1007,11 @@ def __init__(__self__, *,
:param pulumi.Input[int] cpu_per_unit: Optionally configure the number of CPUs to allocate for each headroom unit. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
:param pulumi.Input[int] memory_per_unit: Optionally configure the amount of memory (MiB) to allocate for each headroom unit.
"""
- OceanLaunchSpecAutoscaleHeadroomArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- num_of_units=num_of_units,
- cpu_per_unit=cpu_per_unit,
- memory_per_unit=memory_per_unit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- num_of_units: Optional[pulumi.Input[int]] = None,
- cpu_per_unit: Optional[pulumi.Input[int]] = None,
- memory_per_unit: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if num_of_units is None and 'numOfUnits' in kwargs:
- num_of_units = kwargs['numOfUnits']
- if num_of_units is None:
- raise TypeError("Missing 'num_of_units' argument")
- if cpu_per_unit is None and 'cpuPerUnit' in kwargs:
- cpu_per_unit = kwargs['cpuPerUnit']
- if memory_per_unit is None and 'memoryPerUnit' in kwargs:
- memory_per_unit = kwargs['memoryPerUnit']
-
- _setter("num_of_units", num_of_units)
+ pulumi.set(__self__, "num_of_units", num_of_units)
if cpu_per_unit is not None:
- _setter("cpu_per_unit", cpu_per_unit)
+ pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
if memory_per_unit is not None:
- _setter("memory_per_unit", memory_per_unit)
+ pulumi.set(__self__, "memory_per_unit", memory_per_unit)
@property
@pulumi.getter(name="numOfUnits")
@@ -1387,38 +1057,13 @@ def __init__(__self__, *,
ebs: Optional[pulumi.Input['OceanLaunchSpecBlockDeviceMappingEbsArgs']] = None,
no_device: Optional[pulumi.Input[str]] = None,
virtual_name: Optional[pulumi.Input[str]] = None):
- OceanLaunchSpecBlockDeviceMappingArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- device_name=device_name,
- ebs=ebs,
- no_device=no_device,
- virtual_name=virtual_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- device_name: Optional[pulumi.Input[str]] = None,
- ebs: Optional[pulumi.Input['OceanLaunchSpecBlockDeviceMappingEbsArgs']] = None,
- no_device: Optional[pulumi.Input[str]] = None,
- virtual_name: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if device_name is None and 'deviceName' in kwargs:
- device_name = kwargs['deviceName']
- if device_name is None:
- raise TypeError("Missing 'device_name' argument")
- if no_device is None and 'noDevice' in kwargs:
- no_device = kwargs['noDevice']
- if virtual_name is None and 'virtualName' in kwargs:
- virtual_name = kwargs['virtualName']
-
- _setter("device_name", device_name)
+ pulumi.set(__self__, "device_name", device_name)
if ebs is not None:
- _setter("ebs", ebs)
+ pulumi.set(__self__, "ebs", ebs)
if no_device is not None:
- _setter("no_device", no_device)
+ pulumi.set(__self__, "no_device", no_device)
if virtual_name is not None:
- _setter("virtual_name", virtual_name)
+ pulumi.set(__self__, "virtual_name", virtual_name)
@property
@pulumi.getter(name="deviceName")
@@ -1469,63 +1114,24 @@ def __init__(__self__, *,
throughput: Optional[pulumi.Input[int]] = None,
volume_size: Optional[pulumi.Input[int]] = None,
volume_type: Optional[pulumi.Input[str]] = None):
- OceanLaunchSpecBlockDeviceMappingEbsArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- delete_on_termination=delete_on_termination,
- dynamic_volume_size=dynamic_volume_size,
- encrypted=encrypted,
- iops=iops,
- kms_key_id=kms_key_id,
- snapshot_id=snapshot_id,
- throughput=throughput,
- volume_size=volume_size,
- volume_type=volume_type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- delete_on_termination: Optional[pulumi.Input[bool]] = None,
- dynamic_volume_size: Optional[pulumi.Input['OceanLaunchSpecBlockDeviceMappingEbsDynamicVolumeSizeArgs']] = None,
- encrypted: Optional[pulumi.Input[bool]] = None,
- iops: Optional[pulumi.Input[int]] = None,
- kms_key_id: Optional[pulumi.Input[str]] = None,
- snapshot_id: Optional[pulumi.Input[str]] = None,
- throughput: Optional[pulumi.Input[int]] = None,
- volume_size: Optional[pulumi.Input[int]] = None,
- volume_type: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if delete_on_termination is None and 'deleteOnTermination' in kwargs:
- delete_on_termination = kwargs['deleteOnTermination']
- if dynamic_volume_size is None and 'dynamicVolumeSize' in kwargs:
- dynamic_volume_size = kwargs['dynamicVolumeSize']
- if kms_key_id is None and 'kmsKeyId' in kwargs:
- kms_key_id = kwargs['kmsKeyId']
- if snapshot_id is None and 'snapshotId' in kwargs:
- snapshot_id = kwargs['snapshotId']
- if volume_size is None and 'volumeSize' in kwargs:
- volume_size = kwargs['volumeSize']
- if volume_type is None and 'volumeType' in kwargs:
- volume_type = kwargs['volumeType']
-
if delete_on_termination is not None:
- _setter("delete_on_termination", delete_on_termination)
+ pulumi.set(__self__, "delete_on_termination", delete_on_termination)
if dynamic_volume_size is not None:
- _setter("dynamic_volume_size", dynamic_volume_size)
+ pulumi.set(__self__, "dynamic_volume_size", dynamic_volume_size)
if encrypted is not None:
- _setter("encrypted", encrypted)
+ pulumi.set(__self__, "encrypted", encrypted)
if iops is not None:
- _setter("iops", iops)
+ pulumi.set(__self__, "iops", iops)
if kms_key_id is not None:
- _setter("kms_key_id", kms_key_id)
+ pulumi.set(__self__, "kms_key_id", kms_key_id)
if snapshot_id is not None:
- _setter("snapshot_id", snapshot_id)
+ pulumi.set(__self__, "snapshot_id", snapshot_id)
if throughput is not None:
- _setter("throughput", throughput)
+ pulumi.set(__self__, "throughput", throughput)
if volume_size is not None:
- _setter("volume_size", volume_size)
+ pulumi.set(__self__, "volume_size", volume_size)
if volume_type is not None:
- _setter("volume_type", volume_type)
+ pulumi.set(__self__, "volume_type", volume_type)
@property
@pulumi.getter(name="deleteOnTermination")
@@ -1615,34 +1221,9 @@ def __init__(__self__, *,
base_size: pulumi.Input[int],
resource: pulumi.Input[str],
size_per_resource_unit: pulumi.Input[int]):
- OceanLaunchSpecBlockDeviceMappingEbsDynamicVolumeSizeArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- base_size=base_size,
- resource=resource,
- size_per_resource_unit=size_per_resource_unit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- base_size: Optional[pulumi.Input[int]] = None,
- resource: Optional[pulumi.Input[str]] = None,
- size_per_resource_unit: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if base_size is None and 'baseSize' in kwargs:
- base_size = kwargs['baseSize']
- if base_size is None:
- raise TypeError("Missing 'base_size' argument")
- if resource is None:
- raise TypeError("Missing 'resource' argument")
- if size_per_resource_unit is None and 'sizePerResourceUnit' in kwargs:
- size_per_resource_unit = kwargs['sizePerResourceUnit']
- if size_per_resource_unit is None:
- raise TypeError("Missing 'size_per_resource_unit' argument")
-
- _setter("base_size", base_size)
- _setter("resource", resource)
- _setter("size_per_resource_unit", size_per_resource_unit)
+ pulumi.set(__self__, "base_size", base_size)
+ pulumi.set(__self__, "resource", resource)
+ pulumi.set(__self__, "size_per_resource_unit", size_per_resource_unit)
@property
@pulumi.getter(name="baseSize")
@@ -1681,28 +1262,9 @@ def __init__(__self__, *,
:param pulumi.Input[str] http_tokens: Determines if a signed token is required or not. Valid values: `optional` or `required`.
:param pulumi.Input[int] http_put_response_hop_limit: An integer from 1 through 64. The desired HTTP PUT response hop limit for instance metadata requests. The larger the number, the further the instance metadata requests can travel.
"""
- OceanLaunchSpecInstanceMetadataOptionsArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- http_tokens=http_tokens,
- http_put_response_hop_limit=http_put_response_hop_limit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- http_tokens: Optional[pulumi.Input[str]] = None,
- http_put_response_hop_limit: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if http_tokens is None and 'httpTokens' in kwargs:
- http_tokens = kwargs['httpTokens']
- if http_tokens is None:
- raise TypeError("Missing 'http_tokens' argument")
- if http_put_response_hop_limit is None and 'httpPutResponseHopLimit' in kwargs:
- http_put_response_hop_limit = kwargs['httpPutResponseHopLimit']
-
- _setter("http_tokens", http_tokens)
+ pulumi.set(__self__, "http_tokens", http_tokens)
if http_put_response_hop_limit is not None:
- _setter("http_put_response_hop_limit", http_put_response_hop_limit)
+ pulumi.set(__self__, "http_put_response_hop_limit", http_put_response_hop_limit)
@property
@pulumi.getter(name="httpTokens")
@@ -1742,42 +1304,11 @@ def __init__(__self__, *,
:param pulumi.Input[str] task_type: The activity that you are scheduling. Valid values: "manualHeadroomUpdate".
:param pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecSchedulingTaskTaskHeadroomArgs']]] task_headrooms: The config of this scheduled task. Depends on the value of taskType.
"""
- OceanLaunchSpecSchedulingTaskArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cron_expression=cron_expression,
- is_enabled=is_enabled,
- task_type=task_type,
- task_headrooms=task_headrooms,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cron_expression: Optional[pulumi.Input[str]] = None,
- is_enabled: Optional[pulumi.Input[bool]] = None,
- task_type: Optional[pulumi.Input[str]] = None,
- task_headrooms: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecSchedulingTaskTaskHeadroomArgs']]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cron_expression is None and 'cronExpression' in kwargs:
- cron_expression = kwargs['cronExpression']
- if cron_expression is None:
- raise TypeError("Missing 'cron_expression' argument")
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
- if is_enabled is None:
- raise TypeError("Missing 'is_enabled' argument")
- if task_type is None and 'taskType' in kwargs:
- task_type = kwargs['taskType']
- if task_type is None:
- raise TypeError("Missing 'task_type' argument")
- if task_headrooms is None and 'taskHeadrooms' in kwargs:
- task_headrooms = kwargs['taskHeadrooms']
-
- _setter("cron_expression", cron_expression)
- _setter("is_enabled", is_enabled)
- _setter("task_type", task_type)
+ pulumi.set(__self__, "cron_expression", cron_expression)
+ pulumi.set(__self__, "is_enabled", is_enabled)
+ pulumi.set(__self__, "task_type", task_type)
if task_headrooms is not None:
- _setter("task_headrooms", task_headrooms)
+ pulumi.set(__self__, "task_headrooms", task_headrooms)
@property
@pulumi.getter(name="cronExpression")
@@ -1839,34 +1370,11 @@ def __init__(__self__, *,
:param pulumi.Input[int] cpu_per_unit: Optionally configure the number of CPUs to allocate for each headroom unit. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
:param pulumi.Input[int] memory_per_unit: Optionally configure the amount of memory (MiB) to allocate for each headroom unit.
"""
- OceanLaunchSpecSchedulingTaskTaskHeadroomArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- num_of_units=num_of_units,
- cpu_per_unit=cpu_per_unit,
- memory_per_unit=memory_per_unit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- num_of_units: Optional[pulumi.Input[int]] = None,
- cpu_per_unit: Optional[pulumi.Input[int]] = None,
- memory_per_unit: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if num_of_units is None and 'numOfUnits' in kwargs:
- num_of_units = kwargs['numOfUnits']
- if num_of_units is None:
- raise TypeError("Missing 'num_of_units' argument")
- if cpu_per_unit is None and 'cpuPerUnit' in kwargs:
- cpu_per_unit = kwargs['cpuPerUnit']
- if memory_per_unit is None and 'memoryPerUnit' in kwargs:
- memory_per_unit = kwargs['memoryPerUnit']
-
- _setter("num_of_units", num_of_units)
+ pulumi.set(__self__, "num_of_units", num_of_units)
if cpu_per_unit is not None:
- _setter("cpu_per_unit", cpu_per_unit)
+ pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
if memory_per_unit is not None:
- _setter("memory_per_unit", memory_per_unit)
+ pulumi.set(__self__, "memory_per_unit", memory_per_unit)
@property
@pulumi.getter(name="numOfUnits")
@@ -1914,21 +1422,8 @@ def __init__(__self__, *,
"""
- OceanLaunchSpecStrategyArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- spot_percentage=spot_percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- spot_percentage: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if spot_percentage is None and 'spotPercentage' in kwargs:
- spot_percentage = kwargs['spotPercentage']
-
if spot_percentage is not None:
- _setter("spot_percentage", spot_percentage)
+ pulumi.set(__self__, "spot_percentage", spot_percentage)
@property
@pulumi.getter(name="spotPercentage")
@@ -1954,25 +1449,8 @@ def __init__(__self__, *,
:param pulumi.Input[str] key: The label key.
:param pulumi.Input[str] value: The label value.
"""
- OceanLaunchSpecTagArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -2006,19 +1484,8 @@ def __init__(__self__, *,
"""
:param pulumi.Input['OceanLoggingExportArgs'] export: Logging Export configuration.
"""
- OceanLoggingArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- export=export,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- export: Optional[pulumi.Input['OceanLoggingExportArgs']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if export is not None:
- _setter("export", export)
+ pulumi.set(__self__, "export", export)
@property
@pulumi.getter
@@ -2040,19 +1507,8 @@ def __init__(__self__, *,
"""
:param pulumi.Input[Sequence[pulumi.Input['OceanLoggingExportS3Args']]] s3s: Exports your cluster's logs to the S3 bucket and subdir configured on the S3 data integration given.
"""
- OceanLoggingExportArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- s3s=s3s,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- s3s: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLoggingExportS3Args']]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if s3s is not None:
- _setter("s3s", s3s)
+ pulumi.set(__self__, "s3s", s3s)
@property
@pulumi.getter
@@ -2074,20 +1530,7 @@ def __init__(__self__, *,
"""
:param pulumi.Input[str] id: The identifier of The S3 data integration to export the logs to.
"""
- OceanLoggingExportS3Args._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- id=id,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- id: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if id is None:
- raise TypeError("Missing 'id' argument")
-
- _setter("id", id)
+ pulumi.set(__self__, "id", id)
@property
@pulumi.getter
@@ -2113,35 +1556,10 @@ def __init__(__self__, *,
:param pulumi.Input[bool] should_optimize_ecs_ami: Boolean. Enable auto image (AMI) update for the ECS container instances. The auto update applies for ECS-Optimized AMIs.
:param pulumi.Input[Sequence[pulumi.Input[str]]] time_windows: Array of strings. Set time windows for image update, at least one time window. Each string is in the format of ddd:hh:mm-ddd:hh:mm ddd. Time windows should not overlap.
"""
- OceanOptimizeImagesArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- perform_at=perform_at,
- should_optimize_ecs_ami=should_optimize_ecs_ami,
- time_windows=time_windows,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- perform_at: Optional[pulumi.Input[str]] = None,
- should_optimize_ecs_ami: Optional[pulumi.Input[bool]] = None,
- time_windows: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if perform_at is None and 'performAt' in kwargs:
- perform_at = kwargs['performAt']
- if perform_at is None:
- raise TypeError("Missing 'perform_at' argument")
- if should_optimize_ecs_ami is None and 'shouldOptimizeEcsAmi' in kwargs:
- should_optimize_ecs_ami = kwargs['shouldOptimizeEcsAmi']
- if should_optimize_ecs_ami is None:
- raise TypeError("Missing 'should_optimize_ecs_ami' argument")
- if time_windows is None and 'timeWindows' in kwargs:
- time_windows = kwargs['timeWindows']
-
- _setter("perform_at", perform_at)
- _setter("should_optimize_ecs_ami", should_optimize_ecs_ami)
+ pulumi.set(__self__, "perform_at", perform_at)
+ pulumi.set(__self__, "should_optimize_ecs_ami", should_optimize_ecs_ami)
if time_windows is not None:
- _setter("time_windows", time_windows)
+ pulumi.set(__self__, "time_windows", time_windows)
@property
@pulumi.getter(name="performAt")
@@ -2189,25 +1607,10 @@ def __init__(__self__, *,
:param pulumi.Input['OceanScheduledTaskShutdownHoursArgs'] shutdown_hours: Set shutdown hours for cluster object.
:param pulumi.Input[Sequence[pulumi.Input['OceanScheduledTaskTaskArgs']]] tasks: The scheduling tasks for the cluster.
"""
- OceanScheduledTaskArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- shutdown_hours=shutdown_hours,
- tasks=tasks,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- shutdown_hours: Optional[pulumi.Input['OceanScheduledTaskShutdownHoursArgs']] = None,
- tasks: Optional[pulumi.Input[Sequence[pulumi.Input['OceanScheduledTaskTaskArgs']]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if shutdown_hours is None and 'shutdownHours' in kwargs:
- shutdown_hours = kwargs['shutdownHours']
-
if shutdown_hours is not None:
- _setter("shutdown_hours", shutdown_hours)
+ pulumi.set(__self__, "shutdown_hours", shutdown_hours)
if tasks is not None:
- _setter("tasks", tasks)
+ pulumi.set(__self__, "tasks", tasks)
@property
@pulumi.getter(name="shutdownHours")
@@ -2243,28 +1646,9 @@ def __init__(__self__, *,
:param pulumi.Input[Sequence[pulumi.Input[str]]] time_windows: Array of strings. Set time windows for image update, at least one time window. Each string is in the format of ddd:hh:mm-ddd:hh:mm ddd. Time windows should not overlap.
:param pulumi.Input[bool] is_enabled: Enable the Ocean ECS autoscaler.
"""
- OceanScheduledTaskShutdownHoursArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- time_windows=time_windows,
- is_enabled=is_enabled,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- time_windows: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- is_enabled: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if time_windows is None and 'timeWindows' in kwargs:
- time_windows = kwargs['timeWindows']
- if time_windows is None:
- raise TypeError("Missing 'time_windows' argument")
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
-
- _setter("time_windows", time_windows)
+ pulumi.set(__self__, "time_windows", time_windows)
if is_enabled is not None:
- _setter("is_enabled", is_enabled)
+ pulumi.set(__self__, "is_enabled", is_enabled)
@property
@pulumi.getter(name="timeWindows")
@@ -2309,36 +1693,9 @@ def __init__(__self__, *,
"""
- OceanScheduledTaskTaskArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cron_expression=cron_expression,
- is_enabled=is_enabled,
- task_type=task_type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cron_expression: Optional[pulumi.Input[str]] = None,
- is_enabled: Optional[pulumi.Input[bool]] = None,
- task_type: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cron_expression is None and 'cronExpression' in kwargs:
- cron_expression = kwargs['cronExpression']
- if cron_expression is None:
- raise TypeError("Missing 'cron_expression' argument")
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
- if is_enabled is None:
- raise TypeError("Missing 'is_enabled' argument")
- if task_type is None and 'taskType' in kwargs:
- task_type = kwargs['taskType']
- if task_type is None:
- raise TypeError("Missing 'task_type' argument")
-
- _setter("cron_expression", cron_expression)
- _setter("is_enabled", is_enabled)
- _setter("task_type", task_type)
+ pulumi.set(__self__, "cron_expression", cron_expression)
+ pulumi.set(__self__, "is_enabled", is_enabled)
+ pulumi.set(__self__, "task_type", task_type)
@property
@pulumi.getter(name="cronExpression")
@@ -2393,25 +1750,8 @@ def __init__(__self__, *,
:param pulumi.Input[str] key: The tag key.
:param pulumi.Input[str] value: The tag value.
"""
- OceanTagArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -2450,40 +1790,13 @@ def __init__(__self__, *,
:param pulumi.Input[bool] auto_apply_tags: will update instance tags on the fly without rolling the cluster.
:param pulumi.Input[bool] conditioned_roll: Spot will perform a cluster Roll in accordance with a relevant modification of the cluster’s settings. When set to true , only specific changes in the cluster’s configuration will trigger a cluster roll (such as AMI, Key Pair, user data, instance types, load balancers, etc).
"""
- OceanUpdatePolicyArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- should_roll=should_roll,
- auto_apply_tags=auto_apply_tags,
- conditioned_roll=conditioned_roll,
- roll_config=roll_config,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- should_roll: Optional[pulumi.Input[bool]] = None,
- auto_apply_tags: Optional[pulumi.Input[bool]] = None,
- conditioned_roll: Optional[pulumi.Input[bool]] = None,
- roll_config: Optional[pulumi.Input['OceanUpdatePolicyRollConfigArgs']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if should_roll is None and 'shouldRoll' in kwargs:
- should_roll = kwargs['shouldRoll']
- if should_roll is None:
- raise TypeError("Missing 'should_roll' argument")
- if auto_apply_tags is None and 'autoApplyTags' in kwargs:
- auto_apply_tags = kwargs['autoApplyTags']
- if conditioned_roll is None and 'conditionedRoll' in kwargs:
- conditioned_roll = kwargs['conditionedRoll']
- if roll_config is None and 'rollConfig' in kwargs:
- roll_config = kwargs['rollConfig']
-
- _setter("should_roll", should_roll)
+ pulumi.set(__self__, "should_roll", should_roll)
if auto_apply_tags is not None:
- _setter("auto_apply_tags", auto_apply_tags)
+ pulumi.set(__self__, "auto_apply_tags", auto_apply_tags)
if conditioned_roll is not None:
- _setter("conditioned_roll", conditioned_roll)
+ pulumi.set(__self__, "conditioned_roll", conditioned_roll)
if roll_config is not None:
- _setter("roll_config", roll_config)
+ pulumi.set(__self__, "roll_config", roll_config)
@property
@pulumi.getter(name="shouldRoll")
@@ -2544,28 +1857,9 @@ def __init__(__self__, *,
import pulumi
```
"""
- OceanUpdatePolicyRollConfigArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- batch_size_percentage=batch_size_percentage,
- batch_min_healthy_percentage=batch_min_healthy_percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- batch_size_percentage: Optional[pulumi.Input[int]] = None,
- batch_min_healthy_percentage: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if batch_size_percentage is None and 'batchSizePercentage' in kwargs:
- batch_size_percentage = kwargs['batchSizePercentage']
- if batch_size_percentage is None:
- raise TypeError("Missing 'batch_size_percentage' argument")
- if batch_min_healthy_percentage is None and 'batchMinHealthyPercentage' in kwargs:
- batch_min_healthy_percentage = kwargs['batchMinHealthyPercentage']
-
- _setter("batch_size_percentage", batch_size_percentage)
+ pulumi.set(__self__, "batch_size_percentage", batch_size_percentage)
if batch_min_healthy_percentage is not None:
- _setter("batch_min_healthy_percentage", batch_min_healthy_percentage)
+ pulumi.set(__self__, "batch_min_healthy_percentage", batch_min_healthy_percentage)
@property
@pulumi.getter(name="batchSizePercentage")
diff --git a/sdk/python/pulumi_spotinst/ecs/ocean.py b/sdk/python/pulumi_spotinst/ecs/ocean.py
index 7aebc8f4..8d22e749 100644
--- a/sdk/python/pulumi_spotinst/ecs/ocean.py
+++ b/sdk/python/pulumi_spotinst/ecs/ocean.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs
from ._inputs import *
@@ -82,193 +82,66 @@ def __init__(__self__, *,
:param pulumi.Input[bool] utilize_reserved_instances: If Reserved instances exist, Ocean will utilize them before launching Spot instances.
:param pulumi.Input[Sequence[pulumi.Input[str]]] whitelists: Instance types allowed in the Ocean cluster. Cannot be configured if `blacklist`/`filters` is configured.
"""
- OceanArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cluster_name=cluster_name,
- region=region,
- security_group_ids=security_group_ids,
- subnet_ids=subnet_ids,
- associate_public_ip_address=associate_public_ip_address,
- autoscaler=autoscaler,
- blacklists=blacklists,
- block_device_mappings=block_device_mappings,
- cluster_orientations=cluster_orientations,
- desired_capacity=desired_capacity,
- draining_timeout=draining_timeout,
- ebs_optimized=ebs_optimized,
- filters=filters,
- iam_instance_profile=iam_instance_profile,
- image_id=image_id,
- instance_metadata_options=instance_metadata_options,
- key_pair=key_pair,
- logging=logging,
- max_size=max_size,
- min_size=min_size,
- monitoring=monitoring,
- name=name,
- optimize_images=optimize_images,
- scheduled_tasks=scheduled_tasks,
- spot_percentage=spot_percentage,
- tags=tags,
- update_policy=update_policy,
- use_as_template_only=use_as_template_only,
- user_data=user_data,
- utilize_commitments=utilize_commitments,
- utilize_reserved_instances=utilize_reserved_instances,
- whitelists=whitelists,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cluster_name: Optional[pulumi.Input[str]] = None,
- region: Optional[pulumi.Input[str]] = None,
- security_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- associate_public_ip_address: Optional[pulumi.Input[bool]] = None,
- autoscaler: Optional[pulumi.Input['OceanAutoscalerArgs']] = None,
- blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- block_device_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['OceanBlockDeviceMappingArgs']]]] = None,
- cluster_orientations: Optional[pulumi.Input[Sequence[pulumi.Input['OceanClusterOrientationArgs']]]] = None,
- desired_capacity: Optional[pulumi.Input[int]] = None,
- draining_timeout: Optional[pulumi.Input[int]] = None,
- ebs_optimized: Optional[pulumi.Input[bool]] = None,
- filters: Optional[pulumi.Input['OceanFiltersArgs']] = None,
- iam_instance_profile: Optional[pulumi.Input[str]] = None,
- image_id: Optional[pulumi.Input[str]] = None,
- instance_metadata_options: Optional[pulumi.Input['OceanInstanceMetadataOptionsArgs']] = None,
- key_pair: Optional[pulumi.Input[str]] = None,
- logging: Optional[pulumi.Input['OceanLoggingArgs']] = None,
- max_size: Optional[pulumi.Input[int]] = None,
- min_size: Optional[pulumi.Input[int]] = None,
- monitoring: Optional[pulumi.Input[bool]] = None,
- name: Optional[pulumi.Input[str]] = None,
- optimize_images: Optional[pulumi.Input['OceanOptimizeImagesArgs']] = None,
- scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['OceanScheduledTaskArgs']]]] = None,
- spot_percentage: Optional[pulumi.Input[int]] = None,
- tags: Optional[pulumi.Input[Sequence[pulumi.Input['OceanTagArgs']]]] = None,
- update_policy: Optional[pulumi.Input['OceanUpdatePolicyArgs']] = None,
- use_as_template_only: Optional[pulumi.Input[bool]] = None,
- user_data: Optional[pulumi.Input[str]] = None,
- utilize_commitments: Optional[pulumi.Input[bool]] = None,
- utilize_reserved_instances: Optional[pulumi.Input[bool]] = None,
- whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cluster_name is None and 'clusterName' in kwargs:
- cluster_name = kwargs['clusterName']
- if cluster_name is None:
- raise TypeError("Missing 'cluster_name' argument")
- if region is None:
- raise TypeError("Missing 'region' argument")
- if security_group_ids is None and 'securityGroupIds' in kwargs:
- security_group_ids = kwargs['securityGroupIds']
- if security_group_ids is None:
- raise TypeError("Missing 'security_group_ids' argument")
- if subnet_ids is None and 'subnetIds' in kwargs:
- subnet_ids = kwargs['subnetIds']
- if subnet_ids is None:
- raise TypeError("Missing 'subnet_ids' argument")
- if associate_public_ip_address is None and 'associatePublicIpAddress' in kwargs:
- associate_public_ip_address = kwargs['associatePublicIpAddress']
- if block_device_mappings is None and 'blockDeviceMappings' in kwargs:
- block_device_mappings = kwargs['blockDeviceMappings']
- if cluster_orientations is None and 'clusterOrientations' in kwargs:
- cluster_orientations = kwargs['clusterOrientations']
- if desired_capacity is None and 'desiredCapacity' in kwargs:
- desired_capacity = kwargs['desiredCapacity']
- if draining_timeout is None and 'drainingTimeout' in kwargs:
- draining_timeout = kwargs['drainingTimeout']
- if ebs_optimized is None and 'ebsOptimized' in kwargs:
- ebs_optimized = kwargs['ebsOptimized']
- if iam_instance_profile is None and 'iamInstanceProfile' in kwargs:
- iam_instance_profile = kwargs['iamInstanceProfile']
- if image_id is None and 'imageId' in kwargs:
- image_id = kwargs['imageId']
- if instance_metadata_options is None and 'instanceMetadataOptions' in kwargs:
- instance_metadata_options = kwargs['instanceMetadataOptions']
- if key_pair is None and 'keyPair' in kwargs:
- key_pair = kwargs['keyPair']
- if max_size is None and 'maxSize' in kwargs:
- max_size = kwargs['maxSize']
- if min_size is None and 'minSize' in kwargs:
- min_size = kwargs['minSize']
- if optimize_images is None and 'optimizeImages' in kwargs:
- optimize_images = kwargs['optimizeImages']
- if scheduled_tasks is None and 'scheduledTasks' in kwargs:
- scheduled_tasks = kwargs['scheduledTasks']
- if spot_percentage is None and 'spotPercentage' in kwargs:
- spot_percentage = kwargs['spotPercentage']
- if update_policy is None and 'updatePolicy' in kwargs:
- update_policy = kwargs['updatePolicy']
- if use_as_template_only is None and 'useAsTemplateOnly' in kwargs:
- use_as_template_only = kwargs['useAsTemplateOnly']
- if user_data is None and 'userData' in kwargs:
- user_data = kwargs['userData']
- if utilize_commitments is None and 'utilizeCommitments' in kwargs:
- utilize_commitments = kwargs['utilizeCommitments']
- if utilize_reserved_instances is None and 'utilizeReservedInstances' in kwargs:
- utilize_reserved_instances = kwargs['utilizeReservedInstances']
-
- _setter("cluster_name", cluster_name)
- _setter("region", region)
- _setter("security_group_ids", security_group_ids)
- _setter("subnet_ids", subnet_ids)
+ pulumi.set(__self__, "cluster_name", cluster_name)
+ pulumi.set(__self__, "region", region)
+ pulumi.set(__self__, "security_group_ids", security_group_ids)
+ pulumi.set(__self__, "subnet_ids", subnet_ids)
if associate_public_ip_address is not None:
- _setter("associate_public_ip_address", associate_public_ip_address)
+ pulumi.set(__self__, "associate_public_ip_address", associate_public_ip_address)
if autoscaler is not None:
- _setter("autoscaler", autoscaler)
+ pulumi.set(__self__, "autoscaler", autoscaler)
if blacklists is not None:
- _setter("blacklists", blacklists)
+ pulumi.set(__self__, "blacklists", blacklists)
if block_device_mappings is not None:
- _setter("block_device_mappings", block_device_mappings)
+ pulumi.set(__self__, "block_device_mappings", block_device_mappings)
if cluster_orientations is not None:
- _setter("cluster_orientations", cluster_orientations)
+ pulumi.set(__self__, "cluster_orientations", cluster_orientations)
if desired_capacity is not None:
- _setter("desired_capacity", desired_capacity)
+ pulumi.set(__self__, "desired_capacity", desired_capacity)
if draining_timeout is not None:
- _setter("draining_timeout", draining_timeout)
+ pulumi.set(__self__, "draining_timeout", draining_timeout)
if ebs_optimized is not None:
- _setter("ebs_optimized", ebs_optimized)
+ pulumi.set(__self__, "ebs_optimized", ebs_optimized)
if filters is not None:
- _setter("filters", filters)
+ pulumi.set(__self__, "filters", filters)
if iam_instance_profile is not None:
- _setter("iam_instance_profile", iam_instance_profile)
+ pulumi.set(__self__, "iam_instance_profile", iam_instance_profile)
if image_id is not None:
- _setter("image_id", image_id)
+ pulumi.set(__self__, "image_id", image_id)
if instance_metadata_options is not None:
- _setter("instance_metadata_options", instance_metadata_options)
+ pulumi.set(__self__, "instance_metadata_options", instance_metadata_options)
if key_pair is not None:
- _setter("key_pair", key_pair)
+ pulumi.set(__self__, "key_pair", key_pair)
if logging is not None:
- _setter("logging", logging)
+ pulumi.set(__self__, "logging", logging)
if max_size is not None:
- _setter("max_size", max_size)
+ pulumi.set(__self__, "max_size", max_size)
if min_size is not None:
- _setter("min_size", min_size)
+ pulumi.set(__self__, "min_size", min_size)
if monitoring is not None:
- _setter("monitoring", monitoring)
+ pulumi.set(__self__, "monitoring", monitoring)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if optimize_images is not None:
- _setter("optimize_images", optimize_images)
+ pulumi.set(__self__, "optimize_images", optimize_images)
if scheduled_tasks is not None:
- _setter("scheduled_tasks", scheduled_tasks)
+ pulumi.set(__self__, "scheduled_tasks", scheduled_tasks)
if spot_percentage is not None:
- _setter("spot_percentage", spot_percentage)
+ pulumi.set(__self__, "spot_percentage", spot_percentage)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
if update_policy is not None:
- _setter("update_policy", update_policy)
+ pulumi.set(__self__, "update_policy", update_policy)
if use_as_template_only is not None:
- _setter("use_as_template_only", use_as_template_only)
+ pulumi.set(__self__, "use_as_template_only", use_as_template_only)
if user_data is not None:
- _setter("user_data", user_data)
+ pulumi.set(__self__, "user_data", user_data)
if utilize_commitments is not None:
- _setter("utilize_commitments", utilize_commitments)
+ pulumi.set(__self__, "utilize_commitments", utilize_commitments)
if utilize_reserved_instances is not None:
- _setter("utilize_reserved_instances", utilize_reserved_instances)
+ pulumi.set(__self__, "utilize_reserved_instances", utilize_reserved_instances)
if whitelists is not None:
- _setter("whitelists", whitelists)
+ pulumi.set(__self__, "whitelists", whitelists)
@property
@pulumi.getter(name="clusterName")
@@ -721,189 +594,70 @@ def __init__(__self__, *,
:param pulumi.Input[bool] utilize_reserved_instances: If Reserved instances exist, Ocean will utilize them before launching Spot instances.
:param pulumi.Input[Sequence[pulumi.Input[str]]] whitelists: Instance types allowed in the Ocean cluster. Cannot be configured if `blacklist`/`filters` is configured.
"""
- _OceanState._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- associate_public_ip_address=associate_public_ip_address,
- autoscaler=autoscaler,
- blacklists=blacklists,
- block_device_mappings=block_device_mappings,
- cluster_name=cluster_name,
- cluster_orientations=cluster_orientations,
- desired_capacity=desired_capacity,
- draining_timeout=draining_timeout,
- ebs_optimized=ebs_optimized,
- filters=filters,
- iam_instance_profile=iam_instance_profile,
- image_id=image_id,
- instance_metadata_options=instance_metadata_options,
- key_pair=key_pair,
- logging=logging,
- max_size=max_size,
- min_size=min_size,
- monitoring=monitoring,
- name=name,
- optimize_images=optimize_images,
- region=region,
- scheduled_tasks=scheduled_tasks,
- security_group_ids=security_group_ids,
- spot_percentage=spot_percentage,
- subnet_ids=subnet_ids,
- tags=tags,
- update_policy=update_policy,
- use_as_template_only=use_as_template_only,
- user_data=user_data,
- utilize_commitments=utilize_commitments,
- utilize_reserved_instances=utilize_reserved_instances,
- whitelists=whitelists,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- associate_public_ip_address: Optional[pulumi.Input[bool]] = None,
- autoscaler: Optional[pulumi.Input['OceanAutoscalerArgs']] = None,
- blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- block_device_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['OceanBlockDeviceMappingArgs']]]] = None,
- cluster_name: Optional[pulumi.Input[str]] = None,
- cluster_orientations: Optional[pulumi.Input[Sequence[pulumi.Input['OceanClusterOrientationArgs']]]] = None,
- desired_capacity: Optional[pulumi.Input[int]] = None,
- draining_timeout: Optional[pulumi.Input[int]] = None,
- ebs_optimized: Optional[pulumi.Input[bool]] = None,
- filters: Optional[pulumi.Input['OceanFiltersArgs']] = None,
- iam_instance_profile: Optional[pulumi.Input[str]] = None,
- image_id: Optional[pulumi.Input[str]] = None,
- instance_metadata_options: Optional[pulumi.Input['OceanInstanceMetadataOptionsArgs']] = None,
- key_pair: Optional[pulumi.Input[str]] = None,
- logging: Optional[pulumi.Input['OceanLoggingArgs']] = None,
- max_size: Optional[pulumi.Input[int]] = None,
- min_size: Optional[pulumi.Input[int]] = None,
- monitoring: Optional[pulumi.Input[bool]] = None,
- name: Optional[pulumi.Input[str]] = None,
- optimize_images: Optional[pulumi.Input['OceanOptimizeImagesArgs']] = None,
- region: Optional[pulumi.Input[str]] = None,
- scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['OceanScheduledTaskArgs']]]] = None,
- security_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- spot_percentage: Optional[pulumi.Input[int]] = None,
- subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- tags: Optional[pulumi.Input[Sequence[pulumi.Input['OceanTagArgs']]]] = None,
- update_policy: Optional[pulumi.Input['OceanUpdatePolicyArgs']] = None,
- use_as_template_only: Optional[pulumi.Input[bool]] = None,
- user_data: Optional[pulumi.Input[str]] = None,
- utilize_commitments: Optional[pulumi.Input[bool]] = None,
- utilize_reserved_instances: Optional[pulumi.Input[bool]] = None,
- whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if associate_public_ip_address is None and 'associatePublicIpAddress' in kwargs:
- associate_public_ip_address = kwargs['associatePublicIpAddress']
- if block_device_mappings is None and 'blockDeviceMappings' in kwargs:
- block_device_mappings = kwargs['blockDeviceMappings']
- if cluster_name is None and 'clusterName' in kwargs:
- cluster_name = kwargs['clusterName']
- if cluster_orientations is None and 'clusterOrientations' in kwargs:
- cluster_orientations = kwargs['clusterOrientations']
- if desired_capacity is None and 'desiredCapacity' in kwargs:
- desired_capacity = kwargs['desiredCapacity']
- if draining_timeout is None and 'drainingTimeout' in kwargs:
- draining_timeout = kwargs['drainingTimeout']
- if ebs_optimized is None and 'ebsOptimized' in kwargs:
- ebs_optimized = kwargs['ebsOptimized']
- if iam_instance_profile is None and 'iamInstanceProfile' in kwargs:
- iam_instance_profile = kwargs['iamInstanceProfile']
- if image_id is None and 'imageId' in kwargs:
- image_id = kwargs['imageId']
- if instance_metadata_options is None and 'instanceMetadataOptions' in kwargs:
- instance_metadata_options = kwargs['instanceMetadataOptions']
- if key_pair is None and 'keyPair' in kwargs:
- key_pair = kwargs['keyPair']
- if max_size is None and 'maxSize' in kwargs:
- max_size = kwargs['maxSize']
- if min_size is None and 'minSize' in kwargs:
- min_size = kwargs['minSize']
- if optimize_images is None and 'optimizeImages' in kwargs:
- optimize_images = kwargs['optimizeImages']
- if scheduled_tasks is None and 'scheduledTasks' in kwargs:
- scheduled_tasks = kwargs['scheduledTasks']
- if security_group_ids is None and 'securityGroupIds' in kwargs:
- security_group_ids = kwargs['securityGroupIds']
- if spot_percentage is None and 'spotPercentage' in kwargs:
- spot_percentage = kwargs['spotPercentage']
- if subnet_ids is None and 'subnetIds' in kwargs:
- subnet_ids = kwargs['subnetIds']
- if update_policy is None and 'updatePolicy' in kwargs:
- update_policy = kwargs['updatePolicy']
- if use_as_template_only is None and 'useAsTemplateOnly' in kwargs:
- use_as_template_only = kwargs['useAsTemplateOnly']
- if user_data is None and 'userData' in kwargs:
- user_data = kwargs['userData']
- if utilize_commitments is None and 'utilizeCommitments' in kwargs:
- utilize_commitments = kwargs['utilizeCommitments']
- if utilize_reserved_instances is None and 'utilizeReservedInstances' in kwargs:
- utilize_reserved_instances = kwargs['utilizeReservedInstances']
-
if associate_public_ip_address is not None:
- _setter("associate_public_ip_address", associate_public_ip_address)
+ pulumi.set(__self__, "associate_public_ip_address", associate_public_ip_address)
if autoscaler is not None:
- _setter("autoscaler", autoscaler)
+ pulumi.set(__self__, "autoscaler", autoscaler)
if blacklists is not None:
- _setter("blacklists", blacklists)
+ pulumi.set(__self__, "blacklists", blacklists)
if block_device_mappings is not None:
- _setter("block_device_mappings", block_device_mappings)
+ pulumi.set(__self__, "block_device_mappings", block_device_mappings)
if cluster_name is not None:
- _setter("cluster_name", cluster_name)
+ pulumi.set(__self__, "cluster_name", cluster_name)
if cluster_orientations is not None:
- _setter("cluster_orientations", cluster_orientations)
+ pulumi.set(__self__, "cluster_orientations", cluster_orientations)
if desired_capacity is not None:
- _setter("desired_capacity", desired_capacity)
+ pulumi.set(__self__, "desired_capacity", desired_capacity)
if draining_timeout is not None:
- _setter("draining_timeout", draining_timeout)
+ pulumi.set(__self__, "draining_timeout", draining_timeout)
if ebs_optimized is not None:
- _setter("ebs_optimized", ebs_optimized)
+ pulumi.set(__self__, "ebs_optimized", ebs_optimized)
if filters is not None:
- _setter("filters", filters)
+ pulumi.set(__self__, "filters", filters)
if iam_instance_profile is not None:
- _setter("iam_instance_profile", iam_instance_profile)
+ pulumi.set(__self__, "iam_instance_profile", iam_instance_profile)
if image_id is not None:
- _setter("image_id", image_id)
+ pulumi.set(__self__, "image_id", image_id)
if instance_metadata_options is not None:
- _setter("instance_metadata_options", instance_metadata_options)
+ pulumi.set(__self__, "instance_metadata_options", instance_metadata_options)
if key_pair is not None:
- _setter("key_pair", key_pair)
+ pulumi.set(__self__, "key_pair", key_pair)
if logging is not None:
- _setter("logging", logging)
+ pulumi.set(__self__, "logging", logging)
if max_size is not None:
- _setter("max_size", max_size)
+ pulumi.set(__self__, "max_size", max_size)
if min_size is not None:
- _setter("min_size", min_size)
+ pulumi.set(__self__, "min_size", min_size)
if monitoring is not None:
- _setter("monitoring", monitoring)
+ pulumi.set(__self__, "monitoring", monitoring)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if optimize_images is not None:
- _setter("optimize_images", optimize_images)
+ pulumi.set(__self__, "optimize_images", optimize_images)
if region is not None:
- _setter("region", region)
+ pulumi.set(__self__, "region", region)
if scheduled_tasks is not None:
- _setter("scheduled_tasks", scheduled_tasks)
+ pulumi.set(__self__, "scheduled_tasks", scheduled_tasks)
if security_group_ids is not None:
- _setter("security_group_ids", security_group_ids)
+ pulumi.set(__self__, "security_group_ids", security_group_ids)
if spot_percentage is not None:
- _setter("spot_percentage", spot_percentage)
+ pulumi.set(__self__, "spot_percentage", spot_percentage)
if subnet_ids is not None:
- _setter("subnet_ids", subnet_ids)
+ pulumi.set(__self__, "subnet_ids", subnet_ids)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
if update_policy is not None:
- _setter("update_policy", update_policy)
+ pulumi.set(__self__, "update_policy", update_policy)
if use_as_template_only is not None:
- _setter("use_as_template_only", use_as_template_only)
+ pulumi.set(__self__, "use_as_template_only", use_as_template_only)
if user_data is not None:
- _setter("user_data", user_data)
+ pulumi.set(__self__, "user_data", user_data)
if utilize_commitments is not None:
- _setter("utilize_commitments", utilize_commitments)
+ pulumi.set(__self__, "utilize_commitments", utilize_commitments)
if utilize_reserved_instances is not None:
- _setter("utilize_reserved_instances", utilize_reserved_instances)
+ pulumi.set(__self__, "utilize_reserved_instances", utilize_reserved_instances)
if whitelists is not None:
- _setter("whitelists", whitelists)
+ pulumi.set(__self__, "whitelists", whitelists)
@property
@pulumi.getter(name="associatePublicIpAddress")
@@ -1397,10 +1151,6 @@ def __init__(__self__, resource_name: str, *args, **kwargs):
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
- kwargs = kwargs or {}
- def _setter(key, value):
- kwargs[key] = value
- OceanArgs._configure(_setter, **kwargs)
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
@@ -1448,7 +1198,6 @@ def _internal_init(__self__,
__props__ = OceanArgs.__new__(OceanArgs)
__props__.__dict__["associate_public_ip_address"] = associate_public_ip_address
- autoscaler = _utilities.configure(autoscaler, OceanAutoscalerArgs, True)
__props__.__dict__["autoscaler"] = autoscaler
__props__.__dict__["blacklists"] = blacklists
__props__.__dict__["block_device_mappings"] = block_device_mappings
@@ -1459,20 +1208,16 @@ def _internal_init(__self__,
__props__.__dict__["desired_capacity"] = desired_capacity
__props__.__dict__["draining_timeout"] = draining_timeout
__props__.__dict__["ebs_optimized"] = ebs_optimized
- filters = _utilities.configure(filters, OceanFiltersArgs, True)
__props__.__dict__["filters"] = filters
__props__.__dict__["iam_instance_profile"] = iam_instance_profile
__props__.__dict__["image_id"] = image_id
- instance_metadata_options = _utilities.configure(instance_metadata_options, OceanInstanceMetadataOptionsArgs, True)
__props__.__dict__["instance_metadata_options"] = instance_metadata_options
__props__.__dict__["key_pair"] = key_pair
- logging = _utilities.configure(logging, OceanLoggingArgs, True)
__props__.__dict__["logging"] = logging
__props__.__dict__["max_size"] = max_size
__props__.__dict__["min_size"] = min_size
__props__.__dict__["monitoring"] = monitoring
__props__.__dict__["name"] = name
- optimize_images = _utilities.configure(optimize_images, OceanOptimizeImagesArgs, True)
__props__.__dict__["optimize_images"] = optimize_images
if region is None and not opts.urn:
raise TypeError("Missing required property 'region'")
@@ -1486,7 +1231,6 @@ def _internal_init(__self__,
raise TypeError("Missing required property 'subnet_ids'")
__props__.__dict__["subnet_ids"] = subnet_ids
__props__.__dict__["tags"] = tags
- update_policy = _utilities.configure(update_policy, OceanUpdatePolicyArgs, True)
__props__.__dict__["update_policy"] = update_policy
__props__.__dict__["use_as_template_only"] = use_as_template_only
__props__.__dict__["user_data"] = user_data
diff --git a/sdk/python/pulumi_spotinst/ecs/ocean_launch_spec.py b/sdk/python/pulumi_spotinst/ecs/ocean_launch_spec.py
index 5975c9b6..e043ec6c 100644
--- a/sdk/python/pulumi_spotinst/ecs/ocean_launch_spec.py
+++ b/sdk/python/pulumi_spotinst/ecs/ocean_launch_spec.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs
from ._inputs import *
@@ -52,110 +52,39 @@ def __init__(__self__, *,
:param pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecTagArgs']]] tags: A key/value mapping of tags to assign to the resource.
:param pulumi.Input[str] user_data: Base64-encoded MIME user data to make available to the instances.
"""
- OceanLaunchSpecArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- ocean_id=ocean_id,
- attributes=attributes,
- autoscale_headrooms=autoscale_headrooms,
- block_device_mappings=block_device_mappings,
- iam_instance_profile=iam_instance_profile,
- image_id=image_id,
- instance_metadata_options=instance_metadata_options,
- instance_types=instance_types,
- name=name,
- preferred_spot_types=preferred_spot_types,
- restrict_scale_down=restrict_scale_down,
- scheduling_tasks=scheduling_tasks,
- security_group_ids=security_group_ids,
- strategies=strategies,
- subnet_ids=subnet_ids,
- tags=tags,
- user_data=user_data,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- ocean_id: Optional[pulumi.Input[str]] = None,
- attributes: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecAttributeArgs']]]] = None,
- autoscale_headrooms: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecAutoscaleHeadroomArgs']]]] = None,
- block_device_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecBlockDeviceMappingArgs']]]] = None,
- iam_instance_profile: Optional[pulumi.Input[str]] = None,
- image_id: Optional[pulumi.Input[str]] = None,
- instance_metadata_options: Optional[pulumi.Input['OceanLaunchSpecInstanceMetadataOptionsArgs']] = None,
- instance_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- name: Optional[pulumi.Input[str]] = None,
- preferred_spot_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- restrict_scale_down: Optional[pulumi.Input[bool]] = None,
- scheduling_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecSchedulingTaskArgs']]]] = None,
- security_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- strategies: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecStrategyArgs']]]] = None,
- subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- tags: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecTagArgs']]]] = None,
- user_data: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if ocean_id is None and 'oceanId' in kwargs:
- ocean_id = kwargs['oceanId']
- if ocean_id is None:
- raise TypeError("Missing 'ocean_id' argument")
- if autoscale_headrooms is None and 'autoscaleHeadrooms' in kwargs:
- autoscale_headrooms = kwargs['autoscaleHeadrooms']
- if block_device_mappings is None and 'blockDeviceMappings' in kwargs:
- block_device_mappings = kwargs['blockDeviceMappings']
- if iam_instance_profile is None and 'iamInstanceProfile' in kwargs:
- iam_instance_profile = kwargs['iamInstanceProfile']
- if image_id is None and 'imageId' in kwargs:
- image_id = kwargs['imageId']
- if instance_metadata_options is None and 'instanceMetadataOptions' in kwargs:
- instance_metadata_options = kwargs['instanceMetadataOptions']
- if instance_types is None and 'instanceTypes' in kwargs:
- instance_types = kwargs['instanceTypes']
- if preferred_spot_types is None and 'preferredSpotTypes' in kwargs:
- preferred_spot_types = kwargs['preferredSpotTypes']
- if restrict_scale_down is None and 'restrictScaleDown' in kwargs:
- restrict_scale_down = kwargs['restrictScaleDown']
- if scheduling_tasks is None and 'schedulingTasks' in kwargs:
- scheduling_tasks = kwargs['schedulingTasks']
- if security_group_ids is None and 'securityGroupIds' in kwargs:
- security_group_ids = kwargs['securityGroupIds']
- if subnet_ids is None and 'subnetIds' in kwargs:
- subnet_ids = kwargs['subnetIds']
- if user_data is None and 'userData' in kwargs:
- user_data = kwargs['userData']
-
- _setter("ocean_id", ocean_id)
+ pulumi.set(__self__, "ocean_id", ocean_id)
if attributes is not None:
- _setter("attributes", attributes)
+ pulumi.set(__self__, "attributes", attributes)
if autoscale_headrooms is not None:
- _setter("autoscale_headrooms", autoscale_headrooms)
+ pulumi.set(__self__, "autoscale_headrooms", autoscale_headrooms)
if block_device_mappings is not None:
- _setter("block_device_mappings", block_device_mappings)
+ pulumi.set(__self__, "block_device_mappings", block_device_mappings)
if iam_instance_profile is not None:
- _setter("iam_instance_profile", iam_instance_profile)
+ pulumi.set(__self__, "iam_instance_profile", iam_instance_profile)
if image_id is not None:
- _setter("image_id", image_id)
+ pulumi.set(__self__, "image_id", image_id)
if instance_metadata_options is not None:
- _setter("instance_metadata_options", instance_metadata_options)
+ pulumi.set(__self__, "instance_metadata_options", instance_metadata_options)
if instance_types is not None:
- _setter("instance_types", instance_types)
+ pulumi.set(__self__, "instance_types", instance_types)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if preferred_spot_types is not None:
- _setter("preferred_spot_types", preferred_spot_types)
+ pulumi.set(__self__, "preferred_spot_types", preferred_spot_types)
if restrict_scale_down is not None:
- _setter("restrict_scale_down", restrict_scale_down)
+ pulumi.set(__self__, "restrict_scale_down", restrict_scale_down)
if scheduling_tasks is not None:
- _setter("scheduling_tasks", scheduling_tasks)
+ pulumi.set(__self__, "scheduling_tasks", scheduling_tasks)
if security_group_ids is not None:
- _setter("security_group_ids", security_group_ids)
+ pulumi.set(__self__, "security_group_ids", security_group_ids)
if strategies is not None:
- _setter("strategies", strategies)
+ pulumi.set(__self__, "strategies", strategies)
if subnet_ids is not None:
- _setter("subnet_ids", subnet_ids)
+ pulumi.set(__self__, "subnet_ids", subnet_ids)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
if user_data is not None:
- _setter("user_data", user_data)
+ pulumi.set(__self__, "user_data", user_data)
@property
@pulumi.getter(name="oceanId")
@@ -398,109 +327,40 @@ def __init__(__self__, *,
:param pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecTagArgs']]] tags: A key/value mapping of tags to assign to the resource.
:param pulumi.Input[str] user_data: Base64-encoded MIME user data to make available to the instances.
"""
- _OceanLaunchSpecState._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- attributes=attributes,
- autoscale_headrooms=autoscale_headrooms,
- block_device_mappings=block_device_mappings,
- iam_instance_profile=iam_instance_profile,
- image_id=image_id,
- instance_metadata_options=instance_metadata_options,
- instance_types=instance_types,
- name=name,
- ocean_id=ocean_id,
- preferred_spot_types=preferred_spot_types,
- restrict_scale_down=restrict_scale_down,
- scheduling_tasks=scheduling_tasks,
- security_group_ids=security_group_ids,
- strategies=strategies,
- subnet_ids=subnet_ids,
- tags=tags,
- user_data=user_data,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- attributes: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecAttributeArgs']]]] = None,
- autoscale_headrooms: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecAutoscaleHeadroomArgs']]]] = None,
- block_device_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecBlockDeviceMappingArgs']]]] = None,
- iam_instance_profile: Optional[pulumi.Input[str]] = None,
- image_id: Optional[pulumi.Input[str]] = None,
- instance_metadata_options: Optional[pulumi.Input['OceanLaunchSpecInstanceMetadataOptionsArgs']] = None,
- instance_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- name: Optional[pulumi.Input[str]] = None,
- ocean_id: Optional[pulumi.Input[str]] = None,
- preferred_spot_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- restrict_scale_down: Optional[pulumi.Input[bool]] = None,
- scheduling_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecSchedulingTaskArgs']]]] = None,
- security_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- strategies: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecStrategyArgs']]]] = None,
- subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- tags: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecTagArgs']]]] = None,
- user_data: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if autoscale_headrooms is None and 'autoscaleHeadrooms' in kwargs:
- autoscale_headrooms = kwargs['autoscaleHeadrooms']
- if block_device_mappings is None and 'blockDeviceMappings' in kwargs:
- block_device_mappings = kwargs['blockDeviceMappings']
- if iam_instance_profile is None and 'iamInstanceProfile' in kwargs:
- iam_instance_profile = kwargs['iamInstanceProfile']
- if image_id is None and 'imageId' in kwargs:
- image_id = kwargs['imageId']
- if instance_metadata_options is None and 'instanceMetadataOptions' in kwargs:
- instance_metadata_options = kwargs['instanceMetadataOptions']
- if instance_types is None and 'instanceTypes' in kwargs:
- instance_types = kwargs['instanceTypes']
- if ocean_id is None and 'oceanId' in kwargs:
- ocean_id = kwargs['oceanId']
- if preferred_spot_types is None and 'preferredSpotTypes' in kwargs:
- preferred_spot_types = kwargs['preferredSpotTypes']
- if restrict_scale_down is None and 'restrictScaleDown' in kwargs:
- restrict_scale_down = kwargs['restrictScaleDown']
- if scheduling_tasks is None and 'schedulingTasks' in kwargs:
- scheduling_tasks = kwargs['schedulingTasks']
- if security_group_ids is None and 'securityGroupIds' in kwargs:
- security_group_ids = kwargs['securityGroupIds']
- if subnet_ids is None and 'subnetIds' in kwargs:
- subnet_ids = kwargs['subnetIds']
- if user_data is None and 'userData' in kwargs:
- user_data = kwargs['userData']
-
if attributes is not None:
- _setter("attributes", attributes)
+ pulumi.set(__self__, "attributes", attributes)
if autoscale_headrooms is not None:
- _setter("autoscale_headrooms", autoscale_headrooms)
+ pulumi.set(__self__, "autoscale_headrooms", autoscale_headrooms)
if block_device_mappings is not None:
- _setter("block_device_mappings", block_device_mappings)
+ pulumi.set(__self__, "block_device_mappings", block_device_mappings)
if iam_instance_profile is not None:
- _setter("iam_instance_profile", iam_instance_profile)
+ pulumi.set(__self__, "iam_instance_profile", iam_instance_profile)
if image_id is not None:
- _setter("image_id", image_id)
+ pulumi.set(__self__, "image_id", image_id)
if instance_metadata_options is not None:
- _setter("instance_metadata_options", instance_metadata_options)
+ pulumi.set(__self__, "instance_metadata_options", instance_metadata_options)
if instance_types is not None:
- _setter("instance_types", instance_types)
+ pulumi.set(__self__, "instance_types", instance_types)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if ocean_id is not None:
- _setter("ocean_id", ocean_id)
+ pulumi.set(__self__, "ocean_id", ocean_id)
if preferred_spot_types is not None:
- _setter("preferred_spot_types", preferred_spot_types)
+ pulumi.set(__self__, "preferred_spot_types", preferred_spot_types)
if restrict_scale_down is not None:
- _setter("restrict_scale_down", restrict_scale_down)
+ pulumi.set(__self__, "restrict_scale_down", restrict_scale_down)
if scheduling_tasks is not None:
- _setter("scheduling_tasks", scheduling_tasks)
+ pulumi.set(__self__, "scheduling_tasks", scheduling_tasks)
if security_group_ids is not None:
- _setter("security_group_ids", security_group_ids)
+ pulumi.set(__self__, "security_group_ids", security_group_ids)
if strategies is not None:
- _setter("strategies", strategies)
+ pulumi.set(__self__, "strategies", strategies)
if subnet_ids is not None:
- _setter("subnet_ids", subnet_ids)
+ pulumi.set(__self__, "subnet_ids", subnet_ids)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
if user_data is not None:
- _setter("user_data", user_data)
+ pulumi.set(__self__, "user_data", user_data)
@property
@pulumi.getter
@@ -984,10 +844,6 @@ def __init__(__self__, resource_name: str, *args, **kwargs):
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
- kwargs = kwargs or {}
- def _setter(key, value):
- kwargs[key] = value
- OceanLaunchSpecArgs._configure(_setter, **kwargs)
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
@@ -1024,7 +880,6 @@ def _internal_init(__self__,
__props__.__dict__["block_device_mappings"] = block_device_mappings
__props__.__dict__["iam_instance_profile"] = iam_instance_profile
__props__.__dict__["image_id"] = image_id
- instance_metadata_options = _utilities.configure(instance_metadata_options, OceanLaunchSpecInstanceMetadataOptionsArgs, True)
__props__.__dict__["instance_metadata_options"] = instance_metadata_options
__props__.__dict__["instance_types"] = instance_types
__props__.__dict__["name"] = name
diff --git a/sdk/python/pulumi_spotinst/ecs/outputs.py b/sdk/python/pulumi_spotinst/ecs/outputs.py
index 85296294..bd719f0f 100644
--- a/sdk/python/pulumi_spotinst/ecs/outputs.py
+++ b/sdk/python/pulumi_spotinst/ecs/outputs.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs
@@ -97,63 +97,24 @@ def __init__(__self__, *,
:param 'OceanAutoscalerResourceLimitsArgs' resource_limits: Optionally set upper and lower bounds on the resource usage of the cluster.
:param bool should_scale_down_non_service_tasks: Option to scale down non-service tasks. If not set, Ocean does not scale down standalone tasks.
"""
- OceanAutoscaler._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- auto_headroom_percentage=auto_headroom_percentage,
- cooldown=cooldown,
- down=down,
- enable_automatic_and_manual_headroom=enable_automatic_and_manual_headroom,
- headroom=headroom,
- is_auto_config=is_auto_config,
- is_enabled=is_enabled,
- resource_limits=resource_limits,
- should_scale_down_non_service_tasks=should_scale_down_non_service_tasks,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- auto_headroom_percentage: Optional[int] = None,
- cooldown: Optional[int] = None,
- down: Optional['outputs.OceanAutoscalerDown'] = None,
- enable_automatic_and_manual_headroom: Optional[bool] = None,
- headroom: Optional['outputs.OceanAutoscalerHeadroom'] = None,
- is_auto_config: Optional[bool] = None,
- is_enabled: Optional[bool] = None,
- resource_limits: Optional['outputs.OceanAutoscalerResourceLimits'] = None,
- should_scale_down_non_service_tasks: Optional[bool] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if auto_headroom_percentage is None and 'autoHeadroomPercentage' in kwargs:
- auto_headroom_percentage = kwargs['autoHeadroomPercentage']
- if enable_automatic_and_manual_headroom is None and 'enableAutomaticAndManualHeadroom' in kwargs:
- enable_automatic_and_manual_headroom = kwargs['enableAutomaticAndManualHeadroom']
- if is_auto_config is None and 'isAutoConfig' in kwargs:
- is_auto_config = kwargs['isAutoConfig']
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
- if resource_limits is None and 'resourceLimits' in kwargs:
- resource_limits = kwargs['resourceLimits']
- if should_scale_down_non_service_tasks is None and 'shouldScaleDownNonServiceTasks' in kwargs:
- should_scale_down_non_service_tasks = kwargs['shouldScaleDownNonServiceTasks']
-
if auto_headroom_percentage is not None:
- _setter("auto_headroom_percentage", auto_headroom_percentage)
+ pulumi.set(__self__, "auto_headroom_percentage", auto_headroom_percentage)
if cooldown is not None:
- _setter("cooldown", cooldown)
+ pulumi.set(__self__, "cooldown", cooldown)
if down is not None:
- _setter("down", down)
+ pulumi.set(__self__, "down", down)
if enable_automatic_and_manual_headroom is not None:
- _setter("enable_automatic_and_manual_headroom", enable_automatic_and_manual_headroom)
+ pulumi.set(__self__, "enable_automatic_and_manual_headroom", enable_automatic_and_manual_headroom)
if headroom is not None:
- _setter("headroom", headroom)
+ pulumi.set(__self__, "headroom", headroom)
if is_auto_config is not None:
- _setter("is_auto_config", is_auto_config)
+ pulumi.set(__self__, "is_auto_config", is_auto_config)
if is_enabled is not None:
- _setter("is_enabled", is_enabled)
+ pulumi.set(__self__, "is_enabled", is_enabled)
if resource_limits is not None:
- _setter("resource_limits", resource_limits)
+ pulumi.set(__self__, "resource_limits", resource_limits)
if should_scale_down_non_service_tasks is not None:
- _setter("should_scale_down_non_service_tasks", should_scale_down_non_service_tasks)
+ pulumi.set(__self__, "should_scale_down_non_service_tasks", should_scale_down_non_service_tasks)
@property
@pulumi.getter(name="autoHeadroomPercentage")
@@ -256,21 +217,8 @@ def __init__(__self__, *,
"""
:param float max_scale_down_percentage: Would represent the maximum % to scale-down. Number between 1-100.
"""
- OceanAutoscalerDown._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- max_scale_down_percentage=max_scale_down_percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- max_scale_down_percentage: Optional[float] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if max_scale_down_percentage is None and 'maxScaleDownPercentage' in kwargs:
- max_scale_down_percentage = kwargs['maxScaleDownPercentage']
-
if max_scale_down_percentage is not None:
- _setter("max_scale_down_percentage", max_scale_down_percentage)
+ pulumi.set(__self__, "max_scale_down_percentage", max_scale_down_percentage)
@property
@pulumi.getter(name="maxScaleDownPercentage")
@@ -313,33 +261,12 @@ def __init__(__self__, *,
:param int memory_per_unit: Optionally configure the amount of memory (MB) to allocate the headroom.
:param int num_of_units: The number of units to retain as headroom, where each unit has the defined headroom CPU and memory.
"""
- OceanAutoscalerHeadroom._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cpu_per_unit=cpu_per_unit,
- memory_per_unit=memory_per_unit,
- num_of_units=num_of_units,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cpu_per_unit: Optional[int] = None,
- memory_per_unit: Optional[int] = None,
- num_of_units: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cpu_per_unit is None and 'cpuPerUnit' in kwargs:
- cpu_per_unit = kwargs['cpuPerUnit']
- if memory_per_unit is None and 'memoryPerUnit' in kwargs:
- memory_per_unit = kwargs['memoryPerUnit']
- if num_of_units is None and 'numOfUnits' in kwargs:
- num_of_units = kwargs['numOfUnits']
-
if cpu_per_unit is not None:
- _setter("cpu_per_unit", cpu_per_unit)
+ pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
if memory_per_unit is not None:
- _setter("memory_per_unit", memory_per_unit)
+ pulumi.set(__self__, "memory_per_unit", memory_per_unit)
if num_of_units is not None:
- _setter("num_of_units", num_of_units)
+ pulumi.set(__self__, "num_of_units", num_of_units)
@property
@pulumi.getter(name="cpuPerUnit")
@@ -394,27 +321,10 @@ def __init__(__self__, *,
:param int max_memory_gib: Maximum amount of Memory (GiB).
:param int max_vcpu: Maximum number of vcpus available.
"""
- OceanAutoscalerResourceLimits._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- max_memory_gib=max_memory_gib,
- max_vcpu=max_vcpu,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- max_memory_gib: Optional[int] = None,
- max_vcpu: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if max_memory_gib is None and 'maxMemoryGib' in kwargs:
- max_memory_gib = kwargs['maxMemoryGib']
- if max_vcpu is None and 'maxVcpu' in kwargs:
- max_vcpu = kwargs['maxVcpu']
-
if max_memory_gib is not None:
- _setter("max_memory_gib", max_memory_gib)
+ pulumi.set(__self__, "max_memory_gib", max_memory_gib)
if max_vcpu is not None:
- _setter("max_vcpu", max_vcpu)
+ pulumi.set(__self__, "max_vcpu", max_vcpu)
@property
@pulumi.getter(name="maxMemoryGib")
@@ -466,38 +376,13 @@ def __init__(__self__, *,
:param 'OceanBlockDeviceMappingEbsArgs' ebs: Object. Set Elastic Block Store properties.
:param str no_device: String. Suppresses the specified device included in the block device mapping of the AMI.
"""
- OceanBlockDeviceMapping._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- device_name=device_name,
- ebs=ebs,
- no_device=no_device,
- virtual_name=virtual_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- device_name: Optional[str] = None,
- ebs: Optional['outputs.OceanBlockDeviceMappingEbs'] = None,
- no_device: Optional[str] = None,
- virtual_name: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if device_name is None and 'deviceName' in kwargs:
- device_name = kwargs['deviceName']
- if device_name is None:
- raise TypeError("Missing 'device_name' argument")
- if no_device is None and 'noDevice' in kwargs:
- no_device = kwargs['noDevice']
- if virtual_name is None and 'virtualName' in kwargs:
- virtual_name = kwargs['virtualName']
-
- _setter("device_name", device_name)
+ pulumi.set(__self__, "device_name", device_name)
if ebs is not None:
- _setter("ebs", ebs)
+ pulumi.set(__self__, "ebs", ebs)
if no_device is not None:
- _setter("no_device", no_device)
+ pulumi.set(__self__, "no_device", no_device)
if virtual_name is not None:
- _setter("virtual_name", virtual_name)
+ pulumi.set(__self__, "virtual_name", virtual_name)
@property
@pulumi.getter(name="deviceName")
@@ -579,63 +464,24 @@ def __init__(__self__, *,
:param int volume_size: Int. The size (in GB) of the volume.
:param str volume_type: String. The type of the volume. Example: `gp2`.
"""
- OceanBlockDeviceMappingEbs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- delete_on_termination=delete_on_termination,
- dynamic_volume_size=dynamic_volume_size,
- encrypted=encrypted,
- iops=iops,
- kms_key_id=kms_key_id,
- snapshot_id=snapshot_id,
- throughput=throughput,
- volume_size=volume_size,
- volume_type=volume_type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- delete_on_termination: Optional[bool] = None,
- dynamic_volume_size: Optional['outputs.OceanBlockDeviceMappingEbsDynamicVolumeSize'] = None,
- encrypted: Optional[bool] = None,
- iops: Optional[int] = None,
- kms_key_id: Optional[str] = None,
- snapshot_id: Optional[str] = None,
- throughput: Optional[int] = None,
- volume_size: Optional[int] = None,
- volume_type: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if delete_on_termination is None and 'deleteOnTermination' in kwargs:
- delete_on_termination = kwargs['deleteOnTermination']
- if dynamic_volume_size is None and 'dynamicVolumeSize' in kwargs:
- dynamic_volume_size = kwargs['dynamicVolumeSize']
- if kms_key_id is None and 'kmsKeyId' in kwargs:
- kms_key_id = kwargs['kmsKeyId']
- if snapshot_id is None and 'snapshotId' in kwargs:
- snapshot_id = kwargs['snapshotId']
- if volume_size is None and 'volumeSize' in kwargs:
- volume_size = kwargs['volumeSize']
- if volume_type is None and 'volumeType' in kwargs:
- volume_type = kwargs['volumeType']
-
if delete_on_termination is not None:
- _setter("delete_on_termination", delete_on_termination)
+ pulumi.set(__self__, "delete_on_termination", delete_on_termination)
if dynamic_volume_size is not None:
- _setter("dynamic_volume_size", dynamic_volume_size)
+ pulumi.set(__self__, "dynamic_volume_size", dynamic_volume_size)
if encrypted is not None:
- _setter("encrypted", encrypted)
+ pulumi.set(__self__, "encrypted", encrypted)
if iops is not None:
- _setter("iops", iops)
+ pulumi.set(__self__, "iops", iops)
if kms_key_id is not None:
- _setter("kms_key_id", kms_key_id)
+ pulumi.set(__self__, "kms_key_id", kms_key_id)
if snapshot_id is not None:
- _setter("snapshot_id", snapshot_id)
+ pulumi.set(__self__, "snapshot_id", snapshot_id)
if throughput is not None:
- _setter("throughput", throughput)
+ pulumi.set(__self__, "throughput", throughput)
if volume_size is not None:
- _setter("volume_size", volume_size)
+ pulumi.set(__self__, "volume_size", volume_size)
if volume_type is not None:
- _setter("volume_type", volume_type)
+ pulumi.set(__self__, "volume_type", volume_type)
@property
@pulumi.getter(name="deleteOnTermination")
@@ -740,34 +586,9 @@ def __init__(__self__, *,
:param str resource: String. Resource type to increase volume size dynamically by. Valid values: `CPU`.
:param int size_per_resource_unit: Int. Additional size (in GB) per resource unit. Example: When the `baseSize=50`, `sizePerResourceUnit=20`, and instance with two CPUs is launched, its total disk size will be: 90GB.
"""
- OceanBlockDeviceMappingEbsDynamicVolumeSize._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- base_size=base_size,
- resource=resource,
- size_per_resource_unit=size_per_resource_unit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- base_size: Optional[int] = None,
- resource: Optional[str] = None,
- size_per_resource_unit: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if base_size is None and 'baseSize' in kwargs:
- base_size = kwargs['baseSize']
- if base_size is None:
- raise TypeError("Missing 'base_size' argument")
- if resource is None:
- raise TypeError("Missing 'resource' argument")
- if size_per_resource_unit is None and 'sizePerResourceUnit' in kwargs:
- size_per_resource_unit = kwargs['sizePerResourceUnit']
- if size_per_resource_unit is None:
- raise TypeError("Missing 'size_per_resource_unit' argument")
-
- _setter("base_size", base_size)
- _setter("resource", resource)
- _setter("size_per_resource_unit", size_per_resource_unit)
+ pulumi.set(__self__, "base_size", base_size)
+ pulumi.set(__self__, "resource", resource)
+ pulumi.set(__self__, "size_per_resource_unit", size_per_resource_unit)
@property
@pulumi.getter(name="baseSize")
@@ -818,21 +639,8 @@ def __init__(__self__, *,
"""
:param str availability_vs_cost: You can control the approach that Ocean takes while launching nodes by configuring this value. Possible values: `costOriented`,`balanced`,`cheapest`.
"""
- OceanClusterOrientation._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- availability_vs_cost=availability_vs_cost,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- availability_vs_cost: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if availability_vs_cost is None and 'availabilityVsCost' in kwargs:
- availability_vs_cost = kwargs['availabilityVsCost']
-
if availability_vs_cost is not None:
- _setter("availability_vs_cost", availability_vs_cost)
+ pulumi.set(__self__, "availability_vs_cost", availability_vs_cost)
@property
@pulumi.getter(name="availabilityVsCost")
@@ -933,123 +741,44 @@ def __init__(__self__, *,
:param Sequence[str] root_device_types: The filtered instance types will have a root device types from this list.
:param Sequence[str] virtualization_types: The filtered instance types will support at least one of the virtualization types from this list.
"""
- OceanFilters._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- architectures=architectures,
- categories=categories,
- disk_types=disk_types,
- exclude_families=exclude_families,
- exclude_metal=exclude_metal,
- hypervisors=hypervisors,
- include_families=include_families,
- is_ena_supported=is_ena_supported,
- max_gpu=max_gpu,
- max_memory_gib=max_memory_gib,
- max_network_performance=max_network_performance,
- max_vcpu=max_vcpu,
- min_enis=min_enis,
- min_gpu=min_gpu,
- min_memory_gib=min_memory_gib,
- min_network_performance=min_network_performance,
- min_vcpu=min_vcpu,
- root_device_types=root_device_types,
- virtualization_types=virtualization_types,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- architectures: Optional[Sequence[str]] = None,
- categories: Optional[Sequence[str]] = None,
- disk_types: Optional[Sequence[str]] = None,
- exclude_families: Optional[Sequence[str]] = None,
- exclude_metal: Optional[bool] = None,
- hypervisors: Optional[Sequence[str]] = None,
- include_families: Optional[Sequence[str]] = None,
- is_ena_supported: Optional[str] = None,
- max_gpu: Optional[int] = None,
- max_memory_gib: Optional[float] = None,
- max_network_performance: Optional[int] = None,
- max_vcpu: Optional[int] = None,
- min_enis: Optional[int] = None,
- min_gpu: Optional[int] = None,
- min_memory_gib: Optional[float] = None,
- min_network_performance: Optional[int] = None,
- min_vcpu: Optional[int] = None,
- root_device_types: Optional[Sequence[str]] = None,
- virtualization_types: Optional[Sequence[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if disk_types is None and 'diskTypes' in kwargs:
- disk_types = kwargs['diskTypes']
- if exclude_families is None and 'excludeFamilies' in kwargs:
- exclude_families = kwargs['excludeFamilies']
- if exclude_metal is None and 'excludeMetal' in kwargs:
- exclude_metal = kwargs['excludeMetal']
- if include_families is None and 'includeFamilies' in kwargs:
- include_families = kwargs['includeFamilies']
- if is_ena_supported is None and 'isEnaSupported' in kwargs:
- is_ena_supported = kwargs['isEnaSupported']
- if max_gpu is None and 'maxGpu' in kwargs:
- max_gpu = kwargs['maxGpu']
- if max_memory_gib is None and 'maxMemoryGib' in kwargs:
- max_memory_gib = kwargs['maxMemoryGib']
- if max_network_performance is None and 'maxNetworkPerformance' in kwargs:
- max_network_performance = kwargs['maxNetworkPerformance']
- if max_vcpu is None and 'maxVcpu' in kwargs:
- max_vcpu = kwargs['maxVcpu']
- if min_enis is None and 'minEnis' in kwargs:
- min_enis = kwargs['minEnis']
- if min_gpu is None and 'minGpu' in kwargs:
- min_gpu = kwargs['minGpu']
- if min_memory_gib is None and 'minMemoryGib' in kwargs:
- min_memory_gib = kwargs['minMemoryGib']
- if min_network_performance is None and 'minNetworkPerformance' in kwargs:
- min_network_performance = kwargs['minNetworkPerformance']
- if min_vcpu is None and 'minVcpu' in kwargs:
- min_vcpu = kwargs['minVcpu']
- if root_device_types is None and 'rootDeviceTypes' in kwargs:
- root_device_types = kwargs['rootDeviceTypes']
- if virtualization_types is None and 'virtualizationTypes' in kwargs:
- virtualization_types = kwargs['virtualizationTypes']
-
if architectures is not None:
- _setter("architectures", architectures)
+ pulumi.set(__self__, "architectures", architectures)
if categories is not None:
- _setter("categories", categories)
+ pulumi.set(__self__, "categories", categories)
if disk_types is not None:
- _setter("disk_types", disk_types)
+ pulumi.set(__self__, "disk_types", disk_types)
if exclude_families is not None:
- _setter("exclude_families", exclude_families)
+ pulumi.set(__self__, "exclude_families", exclude_families)
if exclude_metal is not None:
- _setter("exclude_metal", exclude_metal)
+ pulumi.set(__self__, "exclude_metal", exclude_metal)
if hypervisors is not None:
- _setter("hypervisors", hypervisors)
+ pulumi.set(__self__, "hypervisors", hypervisors)
if include_families is not None:
- _setter("include_families", include_families)
+ pulumi.set(__self__, "include_families", include_families)
if is_ena_supported is not None:
- _setter("is_ena_supported", is_ena_supported)
+ pulumi.set(__self__, "is_ena_supported", is_ena_supported)
if max_gpu is not None:
- _setter("max_gpu", max_gpu)
+ pulumi.set(__self__, "max_gpu", max_gpu)
if max_memory_gib is not None:
- _setter("max_memory_gib", max_memory_gib)
+ pulumi.set(__self__, "max_memory_gib", max_memory_gib)
if max_network_performance is not None:
- _setter("max_network_performance", max_network_performance)
+ pulumi.set(__self__, "max_network_performance", max_network_performance)
if max_vcpu is not None:
- _setter("max_vcpu", max_vcpu)
+ pulumi.set(__self__, "max_vcpu", max_vcpu)
if min_enis is not None:
- _setter("min_enis", min_enis)
+ pulumi.set(__self__, "min_enis", min_enis)
if min_gpu is not None:
- _setter("min_gpu", min_gpu)
+ pulumi.set(__self__, "min_gpu", min_gpu)
if min_memory_gib is not None:
- _setter("min_memory_gib", min_memory_gib)
+ pulumi.set(__self__, "min_memory_gib", min_memory_gib)
if min_network_performance is not None:
- _setter("min_network_performance", min_network_performance)
+ pulumi.set(__self__, "min_network_performance", min_network_performance)
if min_vcpu is not None:
- _setter("min_vcpu", min_vcpu)
+ pulumi.set(__self__, "min_vcpu", min_vcpu)
if root_device_types is not None:
- _setter("root_device_types", root_device_types)
+ pulumi.set(__self__, "root_device_types", root_device_types)
if virtualization_types is not None:
- _setter("virtualization_types", virtualization_types)
+ pulumi.set(__self__, "virtualization_types", virtualization_types)
@property
@pulumi.getter
@@ -1232,28 +961,9 @@ def __init__(__self__, *,
:param str http_tokens: Determines if a signed token is required or not. Valid values: `optional` or `required`.
:param int http_put_response_hop_limit: An integer from 1 through 64. The desired HTTP PUT response hop limit for instance metadata requests. The larger the number, the further the instance metadata requests can travel.
"""
- OceanInstanceMetadataOptions._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- http_tokens=http_tokens,
- http_put_response_hop_limit=http_put_response_hop_limit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- http_tokens: Optional[str] = None,
- http_put_response_hop_limit: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if http_tokens is None and 'httpTokens' in kwargs:
- http_tokens = kwargs['httpTokens']
- if http_tokens is None:
- raise TypeError("Missing 'http_tokens' argument")
- if http_put_response_hop_limit is None and 'httpPutResponseHopLimit' in kwargs:
- http_put_response_hop_limit = kwargs['httpPutResponseHopLimit']
-
- _setter("http_tokens", http_tokens)
+ pulumi.set(__self__, "http_tokens", http_tokens)
if http_put_response_hop_limit is not None:
- _setter("http_put_response_hop_limit", http_put_response_hop_limit)
+ pulumi.set(__self__, "http_put_response_hop_limit", http_put_response_hop_limit)
@property
@pulumi.getter(name="httpTokens")
@@ -1281,25 +991,8 @@ def __init__(__self__, *,
:param str key: The label key.
:param str value: The label value.
"""
- OceanLaunchSpecAttribute._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -1350,34 +1043,11 @@ def __init__(__self__, *,
:param int cpu_per_unit: Optionally configure the number of CPUs to allocate for each headroom unit. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
:param int memory_per_unit: Optionally configure the amount of memory (MiB) to allocate for each headroom unit.
"""
- OceanLaunchSpecAutoscaleHeadroom._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- num_of_units=num_of_units,
- cpu_per_unit=cpu_per_unit,
- memory_per_unit=memory_per_unit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- num_of_units: Optional[int] = None,
- cpu_per_unit: Optional[int] = None,
- memory_per_unit: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if num_of_units is None and 'numOfUnits' in kwargs:
- num_of_units = kwargs['numOfUnits']
- if num_of_units is None:
- raise TypeError("Missing 'num_of_units' argument")
- if cpu_per_unit is None and 'cpuPerUnit' in kwargs:
- cpu_per_unit = kwargs['cpuPerUnit']
- if memory_per_unit is None and 'memoryPerUnit' in kwargs:
- memory_per_unit = kwargs['memoryPerUnit']
-
- _setter("num_of_units", num_of_units)
+ pulumi.set(__self__, "num_of_units", num_of_units)
if cpu_per_unit is not None:
- _setter("cpu_per_unit", cpu_per_unit)
+ pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
if memory_per_unit is not None:
- _setter("memory_per_unit", memory_per_unit)
+ pulumi.set(__self__, "memory_per_unit", memory_per_unit)
@property
@pulumi.getter(name="numOfUnits")
@@ -1432,38 +1102,13 @@ def __init__(__self__, *,
ebs: Optional['outputs.OceanLaunchSpecBlockDeviceMappingEbs'] = None,
no_device: Optional[str] = None,
virtual_name: Optional[str] = None):
- OceanLaunchSpecBlockDeviceMapping._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- device_name=device_name,
- ebs=ebs,
- no_device=no_device,
- virtual_name=virtual_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- device_name: Optional[str] = None,
- ebs: Optional['outputs.OceanLaunchSpecBlockDeviceMappingEbs'] = None,
- no_device: Optional[str] = None,
- virtual_name: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if device_name is None and 'deviceName' in kwargs:
- device_name = kwargs['deviceName']
- if device_name is None:
- raise TypeError("Missing 'device_name' argument")
- if no_device is None and 'noDevice' in kwargs:
- no_device = kwargs['noDevice']
- if virtual_name is None and 'virtualName' in kwargs:
- virtual_name = kwargs['virtualName']
-
- _setter("device_name", device_name)
+ pulumi.set(__self__, "device_name", device_name)
if ebs is not None:
- _setter("ebs", ebs)
+ pulumi.set(__self__, "ebs", ebs)
if no_device is not None:
- _setter("no_device", no_device)
+ pulumi.set(__self__, "no_device", no_device)
if virtual_name is not None:
- _setter("virtual_name", virtual_name)
+ pulumi.set(__self__, "virtual_name", virtual_name)
@property
@pulumi.getter(name="deviceName")
@@ -1525,63 +1170,24 @@ def __init__(__self__, *,
throughput: Optional[int] = None,
volume_size: Optional[int] = None,
volume_type: Optional[str] = None):
- OceanLaunchSpecBlockDeviceMappingEbs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- delete_on_termination=delete_on_termination,
- dynamic_volume_size=dynamic_volume_size,
- encrypted=encrypted,
- iops=iops,
- kms_key_id=kms_key_id,
- snapshot_id=snapshot_id,
- throughput=throughput,
- volume_size=volume_size,
- volume_type=volume_type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- delete_on_termination: Optional[bool] = None,
- dynamic_volume_size: Optional['outputs.OceanLaunchSpecBlockDeviceMappingEbsDynamicVolumeSize'] = None,
- encrypted: Optional[bool] = None,
- iops: Optional[int] = None,
- kms_key_id: Optional[str] = None,
- snapshot_id: Optional[str] = None,
- throughput: Optional[int] = None,
- volume_size: Optional[int] = None,
- volume_type: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if delete_on_termination is None and 'deleteOnTermination' in kwargs:
- delete_on_termination = kwargs['deleteOnTermination']
- if dynamic_volume_size is None and 'dynamicVolumeSize' in kwargs:
- dynamic_volume_size = kwargs['dynamicVolumeSize']
- if kms_key_id is None and 'kmsKeyId' in kwargs:
- kms_key_id = kwargs['kmsKeyId']
- if snapshot_id is None and 'snapshotId' in kwargs:
- snapshot_id = kwargs['snapshotId']
- if volume_size is None and 'volumeSize' in kwargs:
- volume_size = kwargs['volumeSize']
- if volume_type is None and 'volumeType' in kwargs:
- volume_type = kwargs['volumeType']
-
if delete_on_termination is not None:
- _setter("delete_on_termination", delete_on_termination)
+ pulumi.set(__self__, "delete_on_termination", delete_on_termination)
if dynamic_volume_size is not None:
- _setter("dynamic_volume_size", dynamic_volume_size)
+ pulumi.set(__self__, "dynamic_volume_size", dynamic_volume_size)
if encrypted is not None:
- _setter("encrypted", encrypted)
+ pulumi.set(__self__, "encrypted", encrypted)
if iops is not None:
- _setter("iops", iops)
+ pulumi.set(__self__, "iops", iops)
if kms_key_id is not None:
- _setter("kms_key_id", kms_key_id)
+ pulumi.set(__self__, "kms_key_id", kms_key_id)
if snapshot_id is not None:
- _setter("snapshot_id", snapshot_id)
+ pulumi.set(__self__, "snapshot_id", snapshot_id)
if throughput is not None:
- _setter("throughput", throughput)
+ pulumi.set(__self__, "throughput", throughput)
if volume_size is not None:
- _setter("volume_size", volume_size)
+ pulumi.set(__self__, "volume_size", volume_size)
if volume_type is not None:
- _setter("volume_type", volume_type)
+ pulumi.set(__self__, "volume_type", volume_type)
@property
@pulumi.getter(name="deleteOnTermination")
@@ -1654,34 +1260,9 @@ def __init__(__self__, *,
base_size: int,
resource: str,
size_per_resource_unit: int):
- OceanLaunchSpecBlockDeviceMappingEbsDynamicVolumeSize._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- base_size=base_size,
- resource=resource,
- size_per_resource_unit=size_per_resource_unit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- base_size: Optional[int] = None,
- resource: Optional[str] = None,
- size_per_resource_unit: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if base_size is None and 'baseSize' in kwargs:
- base_size = kwargs['baseSize']
- if base_size is None:
- raise TypeError("Missing 'base_size' argument")
- if resource is None:
- raise TypeError("Missing 'resource' argument")
- if size_per_resource_unit is None and 'sizePerResourceUnit' in kwargs:
- size_per_resource_unit = kwargs['sizePerResourceUnit']
- if size_per_resource_unit is None:
- raise TypeError("Missing 'size_per_resource_unit' argument")
-
- _setter("base_size", base_size)
- _setter("resource", resource)
- _setter("size_per_resource_unit", size_per_resource_unit)
+ pulumi.set(__self__, "base_size", base_size)
+ pulumi.set(__self__, "resource", resource)
+ pulumi.set(__self__, "size_per_resource_unit", size_per_resource_unit)
@property
@pulumi.getter(name="baseSize")
@@ -1727,28 +1308,9 @@ def __init__(__self__, *,
:param str http_tokens: Determines if a signed token is required or not. Valid values: `optional` or `required`.
:param int http_put_response_hop_limit: An integer from 1 through 64. The desired HTTP PUT response hop limit for instance metadata requests. The larger the number, the further the instance metadata requests can travel.
"""
- OceanLaunchSpecInstanceMetadataOptions._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- http_tokens=http_tokens,
- http_put_response_hop_limit=http_put_response_hop_limit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- http_tokens: Optional[str] = None,
- http_put_response_hop_limit: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if http_tokens is None and 'httpTokens' in kwargs:
- http_tokens = kwargs['httpTokens']
- if http_tokens is None:
- raise TypeError("Missing 'http_tokens' argument")
- if http_put_response_hop_limit is None and 'httpPutResponseHopLimit' in kwargs:
- http_put_response_hop_limit = kwargs['httpPutResponseHopLimit']
-
- _setter("http_tokens", http_tokens)
+ pulumi.set(__self__, "http_tokens", http_tokens)
if http_put_response_hop_limit is not None:
- _setter("http_put_response_hop_limit", http_put_response_hop_limit)
+ pulumi.set(__self__, "http_put_response_hop_limit", http_put_response_hop_limit)
@property
@pulumi.getter(name="httpTokens")
@@ -1803,42 +1365,11 @@ def __init__(__self__, *,
:param str task_type: The activity that you are scheduling. Valid values: "manualHeadroomUpdate".
:param Sequence['OceanLaunchSpecSchedulingTaskTaskHeadroomArgs'] task_headrooms: The config of this scheduled task. Depends on the value of taskType.
"""
- OceanLaunchSpecSchedulingTask._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cron_expression=cron_expression,
- is_enabled=is_enabled,
- task_type=task_type,
- task_headrooms=task_headrooms,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cron_expression: Optional[str] = None,
- is_enabled: Optional[bool] = None,
- task_type: Optional[str] = None,
- task_headrooms: Optional[Sequence['outputs.OceanLaunchSpecSchedulingTaskTaskHeadroom']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cron_expression is None and 'cronExpression' in kwargs:
- cron_expression = kwargs['cronExpression']
- if cron_expression is None:
- raise TypeError("Missing 'cron_expression' argument")
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
- if is_enabled is None:
- raise TypeError("Missing 'is_enabled' argument")
- if task_type is None and 'taskType' in kwargs:
- task_type = kwargs['taskType']
- if task_type is None:
- raise TypeError("Missing 'task_type' argument")
- if task_headrooms is None and 'taskHeadrooms' in kwargs:
- task_headrooms = kwargs['taskHeadrooms']
-
- _setter("cron_expression", cron_expression)
- _setter("is_enabled", is_enabled)
- _setter("task_type", task_type)
+ pulumi.set(__self__, "cron_expression", cron_expression)
+ pulumi.set(__self__, "is_enabled", is_enabled)
+ pulumi.set(__self__, "task_type", task_type)
if task_headrooms is not None:
- _setter("task_headrooms", task_headrooms)
+ pulumi.set(__self__, "task_headrooms", task_headrooms)
@property
@pulumi.getter(name="cronExpression")
@@ -1905,34 +1436,11 @@ def __init__(__self__, *,
:param int cpu_per_unit: Optionally configure the number of CPUs to allocate for each headroom unit. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
:param int memory_per_unit: Optionally configure the amount of memory (MiB) to allocate for each headroom unit.
"""
- OceanLaunchSpecSchedulingTaskTaskHeadroom._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- num_of_units=num_of_units,
- cpu_per_unit=cpu_per_unit,
- memory_per_unit=memory_per_unit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- num_of_units: Optional[int] = None,
- cpu_per_unit: Optional[int] = None,
- memory_per_unit: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if num_of_units is None and 'numOfUnits' in kwargs:
- num_of_units = kwargs['numOfUnits']
- if num_of_units is None:
- raise TypeError("Missing 'num_of_units' argument")
- if cpu_per_unit is None and 'cpuPerUnit' in kwargs:
- cpu_per_unit = kwargs['cpuPerUnit']
- if memory_per_unit is None and 'memoryPerUnit' in kwargs:
- memory_per_unit = kwargs['memoryPerUnit']
-
- _setter("num_of_units", num_of_units)
+ pulumi.set(__self__, "num_of_units", num_of_units)
if cpu_per_unit is not None:
- _setter("cpu_per_unit", cpu_per_unit)
+ pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
if memory_per_unit is not None:
- _setter("memory_per_unit", memory_per_unit)
+ pulumi.set(__self__, "memory_per_unit", memory_per_unit)
@property
@pulumi.getter(name="numOfUnits")
@@ -1985,21 +1493,8 @@ def __init__(__self__, *,
"""
- OceanLaunchSpecStrategy._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- spot_percentage=spot_percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- spot_percentage: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if spot_percentage is None and 'spotPercentage' in kwargs:
- spot_percentage = kwargs['spotPercentage']
-
if spot_percentage is not None:
- _setter("spot_percentage", spot_percentage)
+ pulumi.set(__self__, "spot_percentage", spot_percentage)
@property
@pulumi.getter(name="spotPercentage")
@@ -2021,25 +1516,8 @@ def __init__(__self__, *,
:param str key: The label key.
:param str value: The label value.
"""
- OceanLaunchSpecTag._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -2065,19 +1543,8 @@ def __init__(__self__, *,
"""
:param 'OceanLoggingExportArgs' export: Logging Export configuration.
"""
- OceanLogging._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- export=export,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- export: Optional['outputs.OceanLoggingExport'] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if export is not None:
- _setter("export", export)
+ pulumi.set(__self__, "export", export)
@property
@pulumi.getter
@@ -2095,19 +1562,8 @@ def __init__(__self__, *,
"""
:param Sequence['OceanLoggingExportS3Args'] s3s: Exports your cluster's logs to the S3 bucket and subdir configured on the S3 data integration given.
"""
- OceanLoggingExport._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- s3s=s3s,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- s3s: Optional[Sequence['outputs.OceanLoggingExportS3']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if s3s is not None:
- _setter("s3s", s3s)
+ pulumi.set(__self__, "s3s", s3s)
@property
@pulumi.getter
@@ -2125,20 +1581,7 @@ def __init__(__self__, *,
"""
:param str id: The identifier of The S3 data integration to export the logs to.
"""
- OceanLoggingExportS3._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- id=id,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- id: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if id is None:
- raise TypeError("Missing 'id' argument")
-
- _setter("id", id)
+ pulumi.set(__self__, "id", id)
@property
@pulumi.getter
@@ -2181,35 +1624,10 @@ def __init__(__self__, *,
:param bool should_optimize_ecs_ami: Boolean. Enable auto image (AMI) update for the ECS container instances. The auto update applies for ECS-Optimized AMIs.
:param Sequence[str] time_windows: Array of strings. Set time windows for image update, at least one time window. Each string is in the format of ddd:hh:mm-ddd:hh:mm ddd. Time windows should not overlap.
"""
- OceanOptimizeImages._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- perform_at=perform_at,
- should_optimize_ecs_ami=should_optimize_ecs_ami,
- time_windows=time_windows,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- perform_at: Optional[str] = None,
- should_optimize_ecs_ami: Optional[bool] = None,
- time_windows: Optional[Sequence[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if perform_at is None and 'performAt' in kwargs:
- perform_at = kwargs['performAt']
- if perform_at is None:
- raise TypeError("Missing 'perform_at' argument")
- if should_optimize_ecs_ami is None and 'shouldOptimizeEcsAmi' in kwargs:
- should_optimize_ecs_ami = kwargs['shouldOptimizeEcsAmi']
- if should_optimize_ecs_ami is None:
- raise TypeError("Missing 'should_optimize_ecs_ami' argument")
- if time_windows is None and 'timeWindows' in kwargs:
- time_windows = kwargs['timeWindows']
-
- _setter("perform_at", perform_at)
- _setter("should_optimize_ecs_ami", should_optimize_ecs_ami)
+ pulumi.set(__self__, "perform_at", perform_at)
+ pulumi.set(__self__, "should_optimize_ecs_ami", should_optimize_ecs_ami)
if time_windows is not None:
- _setter("time_windows", time_windows)
+ pulumi.set(__self__, "time_windows", time_windows)
@property
@pulumi.getter(name="performAt")
@@ -2262,25 +1680,10 @@ def __init__(__self__, *,
:param 'OceanScheduledTaskShutdownHoursArgs' shutdown_hours: Set shutdown hours for cluster object.
:param Sequence['OceanScheduledTaskTaskArgs'] tasks: The scheduling tasks for the cluster.
"""
- OceanScheduledTask._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- shutdown_hours=shutdown_hours,
- tasks=tasks,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- shutdown_hours: Optional['outputs.OceanScheduledTaskShutdownHours'] = None,
- tasks: Optional[Sequence['outputs.OceanScheduledTaskTask']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if shutdown_hours is None and 'shutdownHours' in kwargs:
- shutdown_hours = kwargs['shutdownHours']
-
if shutdown_hours is not None:
- _setter("shutdown_hours", shutdown_hours)
+ pulumi.set(__self__, "shutdown_hours", shutdown_hours)
if tasks is not None:
- _setter("tasks", tasks)
+ pulumi.set(__self__, "tasks", tasks)
@property
@pulumi.getter(name="shutdownHours")
@@ -2327,28 +1730,9 @@ def __init__(__self__, *,
:param Sequence[str] time_windows: Array of strings. Set time windows for image update, at least one time window. Each string is in the format of ddd:hh:mm-ddd:hh:mm ddd. Time windows should not overlap.
:param bool is_enabled: Enable the Ocean ECS autoscaler.
"""
- OceanScheduledTaskShutdownHours._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- time_windows=time_windows,
- is_enabled=is_enabled,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- time_windows: Optional[Sequence[str]] = None,
- is_enabled: Optional[bool] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if time_windows is None and 'timeWindows' in kwargs:
- time_windows = kwargs['timeWindows']
- if time_windows is None:
- raise TypeError("Missing 'time_windows' argument")
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
-
- _setter("time_windows", time_windows)
+ pulumi.set(__self__, "time_windows", time_windows)
if is_enabled is not None:
- _setter("is_enabled", is_enabled)
+ pulumi.set(__self__, "is_enabled", is_enabled)
@property
@pulumi.getter(name="timeWindows")
@@ -2406,36 +1790,9 @@ def __init__(__self__, *,
"""
- OceanScheduledTaskTask._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cron_expression=cron_expression,
- is_enabled=is_enabled,
- task_type=task_type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cron_expression: Optional[str] = None,
- is_enabled: Optional[bool] = None,
- task_type: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cron_expression is None and 'cronExpression' in kwargs:
- cron_expression = kwargs['cronExpression']
- if cron_expression is None:
- raise TypeError("Missing 'cron_expression' argument")
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
- if is_enabled is None:
- raise TypeError("Missing 'is_enabled' argument")
- if task_type is None and 'taskType' in kwargs:
- task_type = kwargs['taskType']
- if task_type is None:
- raise TypeError("Missing 'task_type' argument")
-
- _setter("cron_expression", cron_expression)
- _setter("is_enabled", is_enabled)
- _setter("task_type", task_type)
+ pulumi.set(__self__, "cron_expression", cron_expression)
+ pulumi.set(__self__, "is_enabled", is_enabled)
+ pulumi.set(__self__, "task_type", task_type)
@property
@pulumi.getter(name="cronExpression")
@@ -2478,25 +1835,8 @@ def __init__(__self__, *,
:param str key: The tag key.
:param str value: The tag value.
"""
- OceanTag._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -2550,40 +1890,13 @@ def __init__(__self__, *,
:param bool auto_apply_tags: will update instance tags on the fly without rolling the cluster.
:param bool conditioned_roll: Spot will perform a cluster Roll in accordance with a relevant modification of the cluster’s settings. When set to true , only specific changes in the cluster’s configuration will trigger a cluster roll (such as AMI, Key Pair, user data, instance types, load balancers, etc).
"""
- OceanUpdatePolicy._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- should_roll=should_roll,
- auto_apply_tags=auto_apply_tags,
- conditioned_roll=conditioned_roll,
- roll_config=roll_config,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- should_roll: Optional[bool] = None,
- auto_apply_tags: Optional[bool] = None,
- conditioned_roll: Optional[bool] = None,
- roll_config: Optional['outputs.OceanUpdatePolicyRollConfig'] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if should_roll is None and 'shouldRoll' in kwargs:
- should_roll = kwargs['shouldRoll']
- if should_roll is None:
- raise TypeError("Missing 'should_roll' argument")
- if auto_apply_tags is None and 'autoApplyTags' in kwargs:
- auto_apply_tags = kwargs['autoApplyTags']
- if conditioned_roll is None and 'conditionedRoll' in kwargs:
- conditioned_roll = kwargs['conditionedRoll']
- if roll_config is None and 'rollConfig' in kwargs:
- roll_config = kwargs['rollConfig']
-
- _setter("should_roll", should_roll)
+ pulumi.set(__self__, "should_roll", should_roll)
if auto_apply_tags is not None:
- _setter("auto_apply_tags", auto_apply_tags)
+ pulumi.set(__self__, "auto_apply_tags", auto_apply_tags)
if conditioned_roll is not None:
- _setter("conditioned_roll", conditioned_roll)
+ pulumi.set(__self__, "conditioned_roll", conditioned_roll)
if roll_config is not None:
- _setter("roll_config", roll_config)
+ pulumi.set(__self__, "roll_config", roll_config)
@property
@pulumi.getter(name="shouldRoll")
@@ -2647,28 +1960,9 @@ def __init__(__self__, *,
import pulumi
```
"""
- OceanUpdatePolicyRollConfig._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- batch_size_percentage=batch_size_percentage,
- batch_min_healthy_percentage=batch_min_healthy_percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- batch_size_percentage: Optional[int] = None,
- batch_min_healthy_percentage: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if batch_size_percentage is None and 'batchSizePercentage' in kwargs:
- batch_size_percentage = kwargs['batchSizePercentage']
- if batch_size_percentage is None:
- raise TypeError("Missing 'batch_size_percentage' argument")
- if batch_min_healthy_percentage is None and 'batchMinHealthyPercentage' in kwargs:
- batch_min_healthy_percentage = kwargs['batchMinHealthyPercentage']
-
- _setter("batch_size_percentage", batch_size_percentage)
+ pulumi.set(__self__, "batch_size_percentage", batch_size_percentage)
if batch_min_healthy_percentage is not None:
- _setter("batch_min_healthy_percentage", batch_min_healthy_percentage)
+ pulumi.set(__self__, "batch_min_healthy_percentage", batch_min_healthy_percentage)
@property
@pulumi.getter(name="batchSizePercentage")
diff --git a/sdk/python/pulumi_spotinst/elastigroup_azure_v3.py b/sdk/python/pulumi_spotinst/elastigroup_azure_v3.py
index a1f0003b..407195cf 100644
--- a/sdk/python/pulumi_spotinst/elastigroup_azure_v3.py
+++ b/sdk/python/pulumi_spotinst/elastigroup_azure_v3.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from . import _utilities
from . import outputs
from ._inputs import *
@@ -38,122 +38,37 @@ def __init__(__self__, *,
"""
The set of arguments for constructing a ElastigroupAzureV3 resource.
"""
- ElastigroupAzureV3Args._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- fallback_to_on_demand=fallback_to_on_demand,
- network=network,
- od_sizes=od_sizes,
- os=os,
- region=region,
- resource_group_name=resource_group_name,
- spot_sizes=spot_sizes,
- custom_data=custom_data,
- desired_capacity=desired_capacity,
- draining_timeout=draining_timeout,
- images=images,
- login=login,
- managed_service_identities=managed_service_identities,
- max_size=max_size,
- min_size=min_size,
- name=name,
- on_demand_count=on_demand_count,
- spot_percentage=spot_percentage,
- tags=tags,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- fallback_to_on_demand: Optional[pulumi.Input[bool]] = None,
- network: Optional[pulumi.Input['ElastigroupAzureV3NetworkArgs']] = None,
- od_sizes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- os: Optional[pulumi.Input[str]] = None,
- region: Optional[pulumi.Input[str]] = None,
- resource_group_name: Optional[pulumi.Input[str]] = None,
- spot_sizes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- custom_data: Optional[pulumi.Input[str]] = None,
- desired_capacity: Optional[pulumi.Input[int]] = None,
- draining_timeout: Optional[pulumi.Input[int]] = None,
- images: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupAzureV3ImageArgs']]]] = None,
- login: Optional[pulumi.Input['ElastigroupAzureV3LoginArgs']] = None,
- managed_service_identities: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupAzureV3ManagedServiceIdentityArgs']]]] = None,
- max_size: Optional[pulumi.Input[int]] = None,
- min_size: Optional[pulumi.Input[int]] = None,
- name: Optional[pulumi.Input[str]] = None,
- on_demand_count: Optional[pulumi.Input[int]] = None,
- spot_percentage: Optional[pulumi.Input[int]] = None,
- tags: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupAzureV3TagArgs']]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if fallback_to_on_demand is None and 'fallbackToOnDemand' in kwargs:
- fallback_to_on_demand = kwargs['fallbackToOnDemand']
- if fallback_to_on_demand is None:
- raise TypeError("Missing 'fallback_to_on_demand' argument")
- if network is None:
- raise TypeError("Missing 'network' argument")
- if od_sizes is None and 'odSizes' in kwargs:
- od_sizes = kwargs['odSizes']
- if od_sizes is None:
- raise TypeError("Missing 'od_sizes' argument")
- if os is None:
- raise TypeError("Missing 'os' argument")
- if region is None:
- raise TypeError("Missing 'region' argument")
- if resource_group_name is None and 'resourceGroupName' in kwargs:
- resource_group_name = kwargs['resourceGroupName']
- if resource_group_name is None:
- raise TypeError("Missing 'resource_group_name' argument")
- if spot_sizes is None and 'spotSizes' in kwargs:
- spot_sizes = kwargs['spotSizes']
- if spot_sizes is None:
- raise TypeError("Missing 'spot_sizes' argument")
- if custom_data is None and 'customData' in kwargs:
- custom_data = kwargs['customData']
- if desired_capacity is None and 'desiredCapacity' in kwargs:
- desired_capacity = kwargs['desiredCapacity']
- if draining_timeout is None and 'drainingTimeout' in kwargs:
- draining_timeout = kwargs['drainingTimeout']
- if managed_service_identities is None and 'managedServiceIdentities' in kwargs:
- managed_service_identities = kwargs['managedServiceIdentities']
- if max_size is None and 'maxSize' in kwargs:
- max_size = kwargs['maxSize']
- if min_size is None and 'minSize' in kwargs:
- min_size = kwargs['minSize']
- if on_demand_count is None and 'onDemandCount' in kwargs:
- on_demand_count = kwargs['onDemandCount']
- if spot_percentage is None and 'spotPercentage' in kwargs:
- spot_percentage = kwargs['spotPercentage']
-
- _setter("fallback_to_on_demand", fallback_to_on_demand)
- _setter("network", network)
- _setter("od_sizes", od_sizes)
- _setter("os", os)
- _setter("region", region)
- _setter("resource_group_name", resource_group_name)
- _setter("spot_sizes", spot_sizes)
+ pulumi.set(__self__, "fallback_to_on_demand", fallback_to_on_demand)
+ pulumi.set(__self__, "network", network)
+ pulumi.set(__self__, "od_sizes", od_sizes)
+ pulumi.set(__self__, "os", os)
+ pulumi.set(__self__, "region", region)
+ pulumi.set(__self__, "resource_group_name", resource_group_name)
+ pulumi.set(__self__, "spot_sizes", spot_sizes)
if custom_data is not None:
- _setter("custom_data", custom_data)
+ pulumi.set(__self__, "custom_data", custom_data)
if desired_capacity is not None:
- _setter("desired_capacity", desired_capacity)
+ pulumi.set(__self__, "desired_capacity", desired_capacity)
if draining_timeout is not None:
- _setter("draining_timeout", draining_timeout)
+ pulumi.set(__self__, "draining_timeout", draining_timeout)
if images is not None:
- _setter("images", images)
+ pulumi.set(__self__, "images", images)
if login is not None:
- _setter("login", login)
+ pulumi.set(__self__, "login", login)
if managed_service_identities is not None:
- _setter("managed_service_identities", managed_service_identities)
+ pulumi.set(__self__, "managed_service_identities", managed_service_identities)
if max_size is not None:
- _setter("max_size", max_size)
+ pulumi.set(__self__, "max_size", max_size)
if min_size is not None:
- _setter("min_size", min_size)
+ pulumi.set(__self__, "min_size", min_size)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if on_demand_count is not None:
- _setter("on_demand_count", on_demand_count)
+ pulumi.set(__self__, "on_demand_count", on_demand_count)
if spot_percentage is not None:
- _setter("spot_percentage", spot_percentage)
+ pulumi.set(__self__, "spot_percentage", spot_percentage)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
@property
@pulumi.getter(name="fallbackToOnDemand")
@@ -352,115 +267,44 @@ def __init__(__self__, *,
"""
Input properties used for looking up and filtering ElastigroupAzureV3 resources.
"""
- _ElastigroupAzureV3State._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- custom_data=custom_data,
- desired_capacity=desired_capacity,
- draining_timeout=draining_timeout,
- fallback_to_on_demand=fallback_to_on_demand,
- images=images,
- login=login,
- managed_service_identities=managed_service_identities,
- max_size=max_size,
- min_size=min_size,
- name=name,
- network=network,
- od_sizes=od_sizes,
- on_demand_count=on_demand_count,
- os=os,
- region=region,
- resource_group_name=resource_group_name,
- spot_percentage=spot_percentage,
- spot_sizes=spot_sizes,
- tags=tags,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- custom_data: Optional[pulumi.Input[str]] = None,
- desired_capacity: Optional[pulumi.Input[int]] = None,
- draining_timeout: Optional[pulumi.Input[int]] = None,
- fallback_to_on_demand: Optional[pulumi.Input[bool]] = None,
- images: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupAzureV3ImageArgs']]]] = None,
- login: Optional[pulumi.Input['ElastigroupAzureV3LoginArgs']] = None,
- managed_service_identities: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupAzureV3ManagedServiceIdentityArgs']]]] = None,
- max_size: Optional[pulumi.Input[int]] = None,
- min_size: Optional[pulumi.Input[int]] = None,
- name: Optional[pulumi.Input[str]] = None,
- network: Optional[pulumi.Input['ElastigroupAzureV3NetworkArgs']] = None,
- od_sizes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- on_demand_count: Optional[pulumi.Input[int]] = None,
- os: Optional[pulumi.Input[str]] = None,
- region: Optional[pulumi.Input[str]] = None,
- resource_group_name: Optional[pulumi.Input[str]] = None,
- spot_percentage: Optional[pulumi.Input[int]] = None,
- spot_sizes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- tags: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupAzureV3TagArgs']]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if custom_data is None and 'customData' in kwargs:
- custom_data = kwargs['customData']
- if desired_capacity is None and 'desiredCapacity' in kwargs:
- desired_capacity = kwargs['desiredCapacity']
- if draining_timeout is None and 'drainingTimeout' in kwargs:
- draining_timeout = kwargs['drainingTimeout']
- if fallback_to_on_demand is None and 'fallbackToOnDemand' in kwargs:
- fallback_to_on_demand = kwargs['fallbackToOnDemand']
- if managed_service_identities is None and 'managedServiceIdentities' in kwargs:
- managed_service_identities = kwargs['managedServiceIdentities']
- if max_size is None and 'maxSize' in kwargs:
- max_size = kwargs['maxSize']
- if min_size is None and 'minSize' in kwargs:
- min_size = kwargs['minSize']
- if od_sizes is None and 'odSizes' in kwargs:
- od_sizes = kwargs['odSizes']
- if on_demand_count is None and 'onDemandCount' in kwargs:
- on_demand_count = kwargs['onDemandCount']
- if resource_group_name is None and 'resourceGroupName' in kwargs:
- resource_group_name = kwargs['resourceGroupName']
- if spot_percentage is None and 'spotPercentage' in kwargs:
- spot_percentage = kwargs['spotPercentage']
- if spot_sizes is None and 'spotSizes' in kwargs:
- spot_sizes = kwargs['spotSizes']
-
if custom_data is not None:
- _setter("custom_data", custom_data)
+ pulumi.set(__self__, "custom_data", custom_data)
if desired_capacity is not None:
- _setter("desired_capacity", desired_capacity)
+ pulumi.set(__self__, "desired_capacity", desired_capacity)
if draining_timeout is not None:
- _setter("draining_timeout", draining_timeout)
+ pulumi.set(__self__, "draining_timeout", draining_timeout)
if fallback_to_on_demand is not None:
- _setter("fallback_to_on_demand", fallback_to_on_demand)
+ pulumi.set(__self__, "fallback_to_on_demand", fallback_to_on_demand)
if images is not None:
- _setter("images", images)
+ pulumi.set(__self__, "images", images)
if login is not None:
- _setter("login", login)
+ pulumi.set(__self__, "login", login)
if managed_service_identities is not None:
- _setter("managed_service_identities", managed_service_identities)
+ pulumi.set(__self__, "managed_service_identities", managed_service_identities)
if max_size is not None:
- _setter("max_size", max_size)
+ pulumi.set(__self__, "max_size", max_size)
if min_size is not None:
- _setter("min_size", min_size)
+ pulumi.set(__self__, "min_size", min_size)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if network is not None:
- _setter("network", network)
+ pulumi.set(__self__, "network", network)
if od_sizes is not None:
- _setter("od_sizes", od_sizes)
+ pulumi.set(__self__, "od_sizes", od_sizes)
if on_demand_count is not None:
- _setter("on_demand_count", on_demand_count)
+ pulumi.set(__self__, "on_demand_count", on_demand_count)
if os is not None:
- _setter("os", os)
+ pulumi.set(__self__, "os", os)
if region is not None:
- _setter("region", region)
+ pulumi.set(__self__, "region", region)
if resource_group_name is not None:
- _setter("resource_group_name", resource_group_name)
+ pulumi.set(__self__, "resource_group_name", resource_group_name)
if spot_percentage is not None:
- _setter("spot_percentage", spot_percentage)
+ pulumi.set(__self__, "spot_percentage", spot_percentage)
if spot_sizes is not None:
- _setter("spot_sizes", spot_sizes)
+ pulumi.set(__self__, "spot_sizes", spot_sizes)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
@property
@pulumi.getter(name="customData")
@@ -682,10 +526,6 @@ def __init__(__self__, resource_name: str, *args, **kwargs):
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
- kwargs = kwargs or {}
- def _setter(key, value):
- kwargs[key] = value
- ElastigroupAzureV3Args._configure(_setter, **kwargs)
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
@@ -726,13 +566,11 @@ def _internal_init(__self__,
raise TypeError("Missing required property 'fallback_to_on_demand'")
__props__.__dict__["fallback_to_on_demand"] = fallback_to_on_demand
__props__.__dict__["images"] = images
- login = _utilities.configure(login, ElastigroupAzureV3LoginArgs, True)
__props__.__dict__["login"] = login
__props__.__dict__["managed_service_identities"] = managed_service_identities
__props__.__dict__["max_size"] = max_size
__props__.__dict__["min_size"] = min_size
__props__.__dict__["name"] = name
- network = _utilities.configure(network, ElastigroupAzureV3NetworkArgs, True)
if network is None and not opts.urn:
raise TypeError("Missing required property 'network'")
__props__.__dict__["network"] = network
diff --git a/sdk/python/pulumi_spotinst/gcp/_inputs.py b/sdk/python/pulumi_spotinst/gcp/_inputs.py
index ad316292..09f332a0 100644
--- a/sdk/python/pulumi_spotinst/gcp/_inputs.py
+++ b/sdk/python/pulumi_spotinst/gcp/_inputs.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
__all__ = [
@@ -47,38 +47,13 @@ def __init__(__self__, *,
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupBackendServiceNamedPortArgs']]] named_ports: Describes a named port and a list of ports.
:param pulumi.Input[str] scheme: Use when `location_type` is "regional". Set the traffic for the backend service to either between the instances in the vpc or to traffic from the internet. Valid values: `INTERNAL`, `EXTERNAL`.
"""
- ElastigroupBackendServiceArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- service_name=service_name,
- location_type=location_type,
- named_ports=named_ports,
- scheme=scheme,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- service_name: Optional[pulumi.Input[str]] = None,
- location_type: Optional[pulumi.Input[str]] = None,
- named_ports: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupBackendServiceNamedPortArgs']]]] = None,
- scheme: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if service_name is None and 'serviceName' in kwargs:
- service_name = kwargs['serviceName']
- if service_name is None:
- raise TypeError("Missing 'service_name' argument")
- if location_type is None and 'locationType' in kwargs:
- location_type = kwargs['locationType']
- if named_ports is None and 'namedPorts' in kwargs:
- named_ports = kwargs['namedPorts']
-
- _setter("service_name", service_name)
+ pulumi.set(__self__, "service_name", service_name)
if location_type is not None:
- _setter("location_type", location_type)
+ pulumi.set(__self__, "location_type", location_type)
if named_ports is not None:
- _setter("named_ports", named_ports)
+ pulumi.set(__self__, "named_ports", named_ports)
if scheme is not None:
- _setter("scheme", scheme)
+ pulumi.set(__self__, "scheme", scheme)
@property
@pulumi.getter(name="serviceName")
@@ -144,25 +119,8 @@ def __init__(__self__, *,
import pulumi
```
"""
- ElastigroupBackendServiceNamedPortArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- ports=ports,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- ports: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
- if ports is None:
- raise TypeError("Missing 'ports' argument")
-
- _setter("name", name)
- _setter("ports", ports)
+ pulumi.set(__self__, "name", name)
+ pulumi.set(__self__, "ports", ports)
@property
@pulumi.getter
@@ -216,53 +174,22 @@ def __init__(__self__, *,
:param pulumi.Input[str] source: Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.
:param pulumi.Input[str] type: Specifies the type of disk, either SCRATCH or PERSISTENT.
"""
- ElastigroupDiskArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- auto_delete=auto_delete,
- boot=boot,
- device_name=device_name,
- initialize_params=initialize_params,
- interface=interface,
- mode=mode,
- source=source,
- type=type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- auto_delete: Optional[pulumi.Input[bool]] = None,
- boot: Optional[pulumi.Input[bool]] = None,
- device_name: Optional[pulumi.Input[str]] = None,
- initialize_params: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupDiskInitializeParamArgs']]]] = None,
- interface: Optional[pulumi.Input[str]] = None,
- mode: Optional[pulumi.Input[str]] = None,
- source: Optional[pulumi.Input[str]] = None,
- type: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if auto_delete is None and 'autoDelete' in kwargs:
- auto_delete = kwargs['autoDelete']
- if device_name is None and 'deviceName' in kwargs:
- device_name = kwargs['deviceName']
- if initialize_params is None and 'initializeParams' in kwargs:
- initialize_params = kwargs['initializeParams']
-
if auto_delete is not None:
- _setter("auto_delete", auto_delete)
+ pulumi.set(__self__, "auto_delete", auto_delete)
if boot is not None:
- _setter("boot", boot)
+ pulumi.set(__self__, "boot", boot)
if device_name is not None:
- _setter("device_name", device_name)
+ pulumi.set(__self__, "device_name", device_name)
if initialize_params is not None:
- _setter("initialize_params", initialize_params)
+ pulumi.set(__self__, "initialize_params", initialize_params)
if interface is not None:
- _setter("interface", interface)
+ pulumi.set(__self__, "interface", interface)
if mode is not None:
- _setter("mode", mode)
+ pulumi.set(__self__, "mode", mode)
if source is not None:
- _setter("source", source)
+ pulumi.set(__self__, "source", source)
if type is not None:
- _setter("type", type)
+ pulumi.set(__self__, "type", type)
@property
@pulumi.getter(name="autoDelete")
@@ -378,34 +305,11 @@ def __init__(__self__, *,
:param pulumi.Input[str] disk_size_gb: Specifies disk size in gigabytes. Must be in increments of 2.
:param pulumi.Input[str] disk_type: Specifies the disk type to use to create the instance. Valid values: pd-ssd, local-ssd.
"""
- ElastigroupDiskInitializeParamArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- source_image=source_image,
- disk_size_gb=disk_size_gb,
- disk_type=disk_type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- source_image: Optional[pulumi.Input[str]] = None,
- disk_size_gb: Optional[pulumi.Input[str]] = None,
- disk_type: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if source_image is None and 'sourceImage' in kwargs:
- source_image = kwargs['sourceImage']
- if source_image is None:
- raise TypeError("Missing 'source_image' argument")
- if disk_size_gb is None and 'diskSizeGb' in kwargs:
- disk_size_gb = kwargs['diskSizeGb']
- if disk_type is None and 'diskType' in kwargs:
- disk_type = kwargs['diskType']
-
- _setter("source_image", source_image)
+ pulumi.set(__self__, "source_image", source_image)
if disk_size_gb is not None:
- _setter("disk_size_gb", disk_size_gb)
+ pulumi.set(__self__, "disk_size_gb", disk_size_gb)
if disk_type is not None:
- _setter("disk_type", disk_type)
+ pulumi.set(__self__, "disk_type", disk_type)
@property
@pulumi.getter(name="sourceImage")
@@ -465,25 +369,8 @@ def __init__(__self__, *,
```
:param pulumi.Input[str] type: The type of GPU instance. Valid values: `nvidia-tesla-v100`, `nvidia-tesla-p100`, `nvidia-tesla-k80`.
"""
- ElastigroupGpuArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- count=count,
- type=type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- count: Optional[pulumi.Input[int]] = None,
- type: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if count is None:
- raise TypeError("Missing 'count' argument")
- if type is None:
- raise TypeError("Missing 'type' argument")
-
- _setter("count", count)
- _setter("type", type)
+ pulumi.set(__self__, "count", count)
+ pulumi.set(__self__, "type", type)
@property
@pulumi.getter
@@ -524,27 +411,8 @@ def __init__(__self__, *,
"""
:param pulumi.Input[int] memory_gib: The memory (in GiB) in the custom instance types. GCP has a number of limitations on accepted memory values.For more information, see the GCP documentation (here.)[https://cloud.google.com/compute/docs/instances/creating-instance-with-custom-machine-type#specifications]
"""
- ElastigroupInstanceTypesCustomArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- memory_gib=memory_gib,
- vcpu=vcpu,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- memory_gib: Optional[pulumi.Input[int]] = None,
- vcpu: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if memory_gib is None and 'memoryGib' in kwargs:
- memory_gib = kwargs['memoryGib']
- if memory_gib is None:
- raise TypeError("Missing 'memory_gib' argument")
- if vcpu is None:
- raise TypeError("Missing 'vcpu' argument")
-
- _setter("memory_gib", memory_gib)
- _setter("vcpu", vcpu)
+ pulumi.set(__self__, "memory_gib", memory_gib)
+ pulumi.set(__self__, "vcpu", vcpu)
@property
@pulumi.getter(name="memoryGib")
@@ -583,29 +451,8 @@ def __init__(__self__, *,
import pulumi
```
"""
- ElastigroupIntegrationDockerSwarmArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- master_host=master_host,
- master_port=master_port,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- master_host: Optional[pulumi.Input[str]] = None,
- master_port: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if master_host is None and 'masterHost' in kwargs:
- master_host = kwargs['masterHost']
- if master_host is None:
- raise TypeError("Missing 'master_host' argument")
- if master_port is None and 'masterPort' in kwargs:
- master_port = kwargs['masterPort']
- if master_port is None:
- raise TypeError("Missing 'master_port' argument")
-
- _setter("master_host", master_host)
- _setter("master_port", master_port)
+ pulumi.set(__self__, "master_host", master_host)
+ pulumi.set(__self__, "master_port", master_port)
@property
@pulumi.getter(name="masterHost")
@@ -650,67 +497,24 @@ def __init__(__self__, *,
autoscale_labels: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupIntegrationGkeAutoscaleLabelArgs']]]] = None,
cluster_id: Optional[pulumi.Input[str]] = None,
location: Optional[pulumi.Input[str]] = None):
- ElastigroupIntegrationGkeArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- auto_update=auto_update,
- autoscale_cooldown=autoscale_cooldown,
- autoscale_down=autoscale_down,
- autoscale_headroom=autoscale_headroom,
- autoscale_is_auto_config=autoscale_is_auto_config,
- autoscale_is_enabled=autoscale_is_enabled,
- autoscale_labels=autoscale_labels,
- cluster_id=cluster_id,
- location=location,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- auto_update: Optional[pulumi.Input[bool]] = None,
- autoscale_cooldown: Optional[pulumi.Input[int]] = None,
- autoscale_down: Optional[pulumi.Input['ElastigroupIntegrationGkeAutoscaleDownArgs']] = None,
- autoscale_headroom: Optional[pulumi.Input['ElastigroupIntegrationGkeAutoscaleHeadroomArgs']] = None,
- autoscale_is_auto_config: Optional[pulumi.Input[bool]] = None,
- autoscale_is_enabled: Optional[pulumi.Input[bool]] = None,
- autoscale_labels: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupIntegrationGkeAutoscaleLabelArgs']]]] = None,
- cluster_id: Optional[pulumi.Input[str]] = None,
- location: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if auto_update is None and 'autoUpdate' in kwargs:
- auto_update = kwargs['autoUpdate']
- if autoscale_cooldown is None and 'autoscaleCooldown' in kwargs:
- autoscale_cooldown = kwargs['autoscaleCooldown']
- if autoscale_down is None and 'autoscaleDown' in kwargs:
- autoscale_down = kwargs['autoscaleDown']
- if autoscale_headroom is None and 'autoscaleHeadroom' in kwargs:
- autoscale_headroom = kwargs['autoscaleHeadroom']
- if autoscale_is_auto_config is None and 'autoscaleIsAutoConfig' in kwargs:
- autoscale_is_auto_config = kwargs['autoscaleIsAutoConfig']
- if autoscale_is_enabled is None and 'autoscaleIsEnabled' in kwargs:
- autoscale_is_enabled = kwargs['autoscaleIsEnabled']
- if autoscale_labels is None and 'autoscaleLabels' in kwargs:
- autoscale_labels = kwargs['autoscaleLabels']
- if cluster_id is None and 'clusterId' in kwargs:
- cluster_id = kwargs['clusterId']
-
if auto_update is not None:
- _setter("auto_update", auto_update)
+ pulumi.set(__self__, "auto_update", auto_update)
if autoscale_cooldown is not None:
- _setter("autoscale_cooldown", autoscale_cooldown)
+ pulumi.set(__self__, "autoscale_cooldown", autoscale_cooldown)
if autoscale_down is not None:
- _setter("autoscale_down", autoscale_down)
+ pulumi.set(__self__, "autoscale_down", autoscale_down)
if autoscale_headroom is not None:
- _setter("autoscale_headroom", autoscale_headroom)
+ pulumi.set(__self__, "autoscale_headroom", autoscale_headroom)
if autoscale_is_auto_config is not None:
- _setter("autoscale_is_auto_config", autoscale_is_auto_config)
+ pulumi.set(__self__, "autoscale_is_auto_config", autoscale_is_auto_config)
if autoscale_is_enabled is not None:
- _setter("autoscale_is_enabled", autoscale_is_enabled)
+ pulumi.set(__self__, "autoscale_is_enabled", autoscale_is_enabled)
if autoscale_labels is not None:
- _setter("autoscale_labels", autoscale_labels)
+ pulumi.set(__self__, "autoscale_labels", autoscale_labels)
if cluster_id is not None:
- _setter("cluster_id", cluster_id)
+ pulumi.set(__self__, "cluster_id", cluster_id)
if location is not None:
- _setter("location", location)
+ pulumi.set(__self__, "location", location)
@property
@pulumi.getter(name="autoUpdate")
@@ -801,21 +605,8 @@ def __init__(__self__, *,
"""
:param pulumi.Input[int] evaluation_periods: Number of consecutive periods in which the threshold must be met in order to trigger a scaling action.
"""
- ElastigroupIntegrationGkeAutoscaleDownArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- evaluation_periods=evaluation_periods,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- evaluation_periods: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
-
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
@property
@pulumi.getter(name="evaluationPeriods")
@@ -836,33 +627,12 @@ def __init__(__self__, *,
cpu_per_unit: Optional[pulumi.Input[int]] = None,
memory_per_unit: Optional[pulumi.Input[int]] = None,
num_of_units: Optional[pulumi.Input[int]] = None):
- ElastigroupIntegrationGkeAutoscaleHeadroomArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cpu_per_unit=cpu_per_unit,
- memory_per_unit=memory_per_unit,
- num_of_units=num_of_units,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cpu_per_unit: Optional[pulumi.Input[int]] = None,
- memory_per_unit: Optional[pulumi.Input[int]] = None,
- num_of_units: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cpu_per_unit is None and 'cpuPerUnit' in kwargs:
- cpu_per_unit = kwargs['cpuPerUnit']
- if memory_per_unit is None and 'memoryPerUnit' in kwargs:
- memory_per_unit = kwargs['memoryPerUnit']
- if num_of_units is None and 'numOfUnits' in kwargs:
- num_of_units = kwargs['numOfUnits']
-
if cpu_per_unit is not None:
- _setter("cpu_per_unit", cpu_per_unit)
+ pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
if memory_per_unit is not None:
- _setter("memory_per_unit", memory_per_unit)
+ pulumi.set(__self__, "memory_per_unit", memory_per_unit)
if num_of_units is not None:
- _setter("num_of_units", num_of_units)
+ pulumi.set(__self__, "num_of_units", num_of_units)
@property
@pulumi.getter(name="cpuPerUnit")
@@ -901,25 +671,8 @@ def __init__(__self__, *,
:param pulumi.Input[str] key: Labels key.
:param pulumi.Input[str] value: Labels value.
"""
- ElastigroupIntegrationGkeAutoscaleLabelArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -955,25 +708,8 @@ def __init__(__self__, *,
:param pulumi.Input[str] key: Labels key.
:param pulumi.Input[str] value: Labels value.
"""
- ElastigroupLabelArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -1009,25 +745,8 @@ def __init__(__self__, *,
:param pulumi.Input[str] key: Labels key.
:param pulumi.Input[str] value: Labels value.
"""
- ElastigroupMetadataArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -1064,32 +783,11 @@ def __init__(__self__, *,
:param pulumi.Input[str] network: Network resource for this group.
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceAccessConfigArgs']]] access_configs: Array of configurations.
"""
- ElastigroupNetworkInterfaceArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- network=network,
- access_configs=access_configs,
- alias_ip_ranges=alias_ip_ranges,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- network: Optional[pulumi.Input[str]] = None,
- access_configs: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceAccessConfigArgs']]]] = None,
- alias_ip_ranges: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceAliasIpRangeArgs']]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if network is None:
- raise TypeError("Missing 'network' argument")
- if access_configs is None and 'accessConfigs' in kwargs:
- access_configs = kwargs['accessConfigs']
- if alias_ip_ranges is None and 'aliasIpRanges' in kwargs:
- alias_ip_ranges = kwargs['aliasIpRanges']
-
- _setter("network", network)
+ pulumi.set(__self__, "network", network)
if access_configs is not None:
- _setter("access_configs", access_configs)
+ pulumi.set(__self__, "access_configs", access_configs)
if alias_ip_ranges is not None:
- _setter("alias_ip_ranges", alias_ip_ranges)
+ pulumi.set(__self__, "alias_ip_ranges", alias_ip_ranges)
@property
@pulumi.getter
@@ -1134,23 +832,10 @@ def __init__(__self__, *,
:param pulumi.Input[str] name: The group name.
:param pulumi.Input[str] type: Specifies the type of disk, either SCRATCH or PERSISTENT.
"""
- ElastigroupNetworkInterfaceAccessConfigArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- type=type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- type: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if type is not None:
- _setter("type", type)
+ pulumi.set(__self__, "type", type)
@property
@pulumi.getter
@@ -1182,29 +867,8 @@ class ElastigroupNetworkInterfaceAliasIpRangeArgs:
def __init__(__self__, *,
ip_cidr_range: pulumi.Input[str],
subnetwork_range_name: pulumi.Input[str]):
- ElastigroupNetworkInterfaceAliasIpRangeArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- ip_cidr_range=ip_cidr_range,
- subnetwork_range_name=subnetwork_range_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- ip_cidr_range: Optional[pulumi.Input[str]] = None,
- subnetwork_range_name: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if ip_cidr_range is None and 'ipCidrRange' in kwargs:
- ip_cidr_range = kwargs['ipCidrRange']
- if ip_cidr_range is None:
- raise TypeError("Missing 'ip_cidr_range' argument")
- if subnetwork_range_name is None and 'subnetworkRangeName' in kwargs:
- subnetwork_range_name = kwargs['subnetworkRangeName']
- if subnetwork_range_name is None:
- raise TypeError("Missing 'subnetwork_range_name' argument")
-
- _setter("ip_cidr_range", ip_cidr_range)
- _setter("subnetwork_range_name", subnetwork_range_name)
+ pulumi.set(__self__, "ip_cidr_range", ip_cidr_range)
+ pulumi.set(__self__, "subnetwork_range_name", subnetwork_range_name)
@property
@pulumi.getter(name="ipCidrRange")
@@ -1256,84 +920,29 @@ def __init__(__self__, *,
:param pulumi.Input[str] source: Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.
:param pulumi.Input[str] statistic: Statistic by which to evaluate the selected metric. Valid values: "AVERAGE", "SAMPLE_COUNT", "SUM", "MINIMUM", "MAXIMUM", "PERCENTILE", "COUNT".
"""
- ElastigroupScalingDownPolicyArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- metric_name=metric_name,
- namespace=namespace,
- policy_name=policy_name,
- threshold=threshold,
- unit=unit,
- action_type=action_type,
- adjustment=adjustment,
- cooldown=cooldown,
- dimensions=dimensions,
- evaluation_periods=evaluation_periods,
- operator=operator,
- period=period,
- source=source,
- statistic=statistic,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- metric_name: Optional[pulumi.Input[str]] = None,
- namespace: Optional[pulumi.Input[str]] = None,
- policy_name: Optional[pulumi.Input[str]] = None,
- threshold: Optional[pulumi.Input[float]] = None,
- unit: Optional[pulumi.Input[str]] = None,
- action_type: Optional[pulumi.Input[str]] = None,
- adjustment: Optional[pulumi.Input[int]] = None,
- cooldown: Optional[pulumi.Input[int]] = None,
- dimensions: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyDimensionArgs']]]] = None,
- evaluation_periods: Optional[pulumi.Input[int]] = None,
- operator: Optional[pulumi.Input[str]] = None,
- period: Optional[pulumi.Input[int]] = None,
- source: Optional[pulumi.Input[str]] = None,
- statistic: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if metric_name is None and 'metricName' in kwargs:
- metric_name = kwargs['metricName']
- if metric_name is None:
- raise TypeError("Missing 'metric_name' argument")
- if namespace is None:
- raise TypeError("Missing 'namespace' argument")
- if policy_name is None and 'policyName' in kwargs:
- policy_name = kwargs['policyName']
- if policy_name is None:
- raise TypeError("Missing 'policy_name' argument")
- if threshold is None:
- raise TypeError("Missing 'threshold' argument")
- if unit is None:
- raise TypeError("Missing 'unit' argument")
- if action_type is None and 'actionType' in kwargs:
- action_type = kwargs['actionType']
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
-
- _setter("metric_name", metric_name)
- _setter("namespace", namespace)
- _setter("policy_name", policy_name)
- _setter("threshold", threshold)
- _setter("unit", unit)
+ pulumi.set(__self__, "metric_name", metric_name)
+ pulumi.set(__self__, "namespace", namespace)
+ pulumi.set(__self__, "policy_name", policy_name)
+ pulumi.set(__self__, "threshold", threshold)
+ pulumi.set(__self__, "unit", unit)
if action_type is not None:
- _setter("action_type", action_type)
+ pulumi.set(__self__, "action_type", action_type)
if adjustment is not None:
- _setter("adjustment", adjustment)
+ pulumi.set(__self__, "adjustment", adjustment)
if cooldown is not None:
- _setter("cooldown", cooldown)
+ pulumi.set(__self__, "cooldown", cooldown)
if dimensions is not None:
- _setter("dimensions", dimensions)
+ pulumi.set(__self__, "dimensions", dimensions)
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
if operator is not None:
- _setter("operator", operator)
+ pulumi.set(__self__, "operator", operator)
if period is not None:
- _setter("period", period)
+ pulumi.set(__self__, "period", period)
if source is not None:
- _setter("source", source)
+ pulumi.set(__self__, "source", source)
if statistic is not None:
- _setter("statistic", statistic)
+ pulumi.set(__self__, "statistic", statistic)
@property
@pulumi.getter(name="metricName")
@@ -1507,24 +1116,9 @@ def __init__(__self__, *,
:param pulumi.Input[str] name: The group name.
:param pulumi.Input[str] value: Labels value.
"""
- ElastigroupScalingDownPolicyDimensionArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
-
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if value is not None:
- _setter("value", value)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -1582,84 +1176,29 @@ def __init__(__self__, *,
:param pulumi.Input[str] source: Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.
:param pulumi.Input[str] statistic: Statistic by which to evaluate the selected metric. Valid values: "AVERAGE", "SAMPLE_COUNT", "SUM", "MINIMUM", "MAXIMUM", "PERCENTILE", "COUNT".
"""
- ElastigroupScalingUpPolicyArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- metric_name=metric_name,
- namespace=namespace,
- policy_name=policy_name,
- threshold=threshold,
- unit=unit,
- action_type=action_type,
- adjustment=adjustment,
- cooldown=cooldown,
- dimensions=dimensions,
- evaluation_periods=evaluation_periods,
- operator=operator,
- period=period,
- source=source,
- statistic=statistic,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- metric_name: Optional[pulumi.Input[str]] = None,
- namespace: Optional[pulumi.Input[str]] = None,
- policy_name: Optional[pulumi.Input[str]] = None,
- threshold: Optional[pulumi.Input[float]] = None,
- unit: Optional[pulumi.Input[str]] = None,
- action_type: Optional[pulumi.Input[str]] = None,
- adjustment: Optional[pulumi.Input[int]] = None,
- cooldown: Optional[pulumi.Input[int]] = None,
- dimensions: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyDimensionArgs']]]] = None,
- evaluation_periods: Optional[pulumi.Input[int]] = None,
- operator: Optional[pulumi.Input[str]] = None,
- period: Optional[pulumi.Input[int]] = None,
- source: Optional[pulumi.Input[str]] = None,
- statistic: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if metric_name is None and 'metricName' in kwargs:
- metric_name = kwargs['metricName']
- if metric_name is None:
- raise TypeError("Missing 'metric_name' argument")
- if namespace is None:
- raise TypeError("Missing 'namespace' argument")
- if policy_name is None and 'policyName' in kwargs:
- policy_name = kwargs['policyName']
- if policy_name is None:
- raise TypeError("Missing 'policy_name' argument")
- if threshold is None:
- raise TypeError("Missing 'threshold' argument")
- if unit is None:
- raise TypeError("Missing 'unit' argument")
- if action_type is None and 'actionType' in kwargs:
- action_type = kwargs['actionType']
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
-
- _setter("metric_name", metric_name)
- _setter("namespace", namespace)
- _setter("policy_name", policy_name)
- _setter("threshold", threshold)
- _setter("unit", unit)
+ pulumi.set(__self__, "metric_name", metric_name)
+ pulumi.set(__self__, "namespace", namespace)
+ pulumi.set(__self__, "policy_name", policy_name)
+ pulumi.set(__self__, "threshold", threshold)
+ pulumi.set(__self__, "unit", unit)
if action_type is not None:
- _setter("action_type", action_type)
+ pulumi.set(__self__, "action_type", action_type)
if adjustment is not None:
- _setter("adjustment", adjustment)
+ pulumi.set(__self__, "adjustment", adjustment)
if cooldown is not None:
- _setter("cooldown", cooldown)
+ pulumi.set(__self__, "cooldown", cooldown)
if dimensions is not None:
- _setter("dimensions", dimensions)
+ pulumi.set(__self__, "dimensions", dimensions)
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
if operator is not None:
- _setter("operator", operator)
+ pulumi.set(__self__, "operator", operator)
if period is not None:
- _setter("period", period)
+ pulumi.set(__self__, "period", period)
if source is not None:
- _setter("source", source)
+ pulumi.set(__self__, "source", source)
if statistic is not None:
- _setter("statistic", statistic)
+ pulumi.set(__self__, "statistic", statistic)
@property
@pulumi.getter(name="metricName")
@@ -1833,24 +1372,9 @@ def __init__(__self__, *,
:param pulumi.Input[str] name: The group name.
:param pulumi.Input[str] value: Labels value.
"""
- ElastigroupScalingUpPolicyDimensionArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
-
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if value is not None:
- _setter("value", value)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -1900,52 +1424,17 @@ def __init__(__self__, *,
:param pulumi.Input[str] min_capacity: The minimum number of instances the group should have.
:param pulumi.Input[str] target_capacity: The desired number of instances the group should have.
"""
- ElastigroupScheduledTaskArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- task_type=task_type,
- cron_expression=cron_expression,
- is_enabled=is_enabled,
- max_capacity=max_capacity,
- min_capacity=min_capacity,
- target_capacity=target_capacity,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- task_type: Optional[pulumi.Input[str]] = None,
- cron_expression: Optional[pulumi.Input[str]] = None,
- is_enabled: Optional[pulumi.Input[bool]] = None,
- max_capacity: Optional[pulumi.Input[str]] = None,
- min_capacity: Optional[pulumi.Input[str]] = None,
- target_capacity: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if task_type is None and 'taskType' in kwargs:
- task_type = kwargs['taskType']
- if task_type is None:
- raise TypeError("Missing 'task_type' argument")
- if cron_expression is None and 'cronExpression' in kwargs:
- cron_expression = kwargs['cronExpression']
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
- if max_capacity is None and 'maxCapacity' in kwargs:
- max_capacity = kwargs['maxCapacity']
- if min_capacity is None and 'minCapacity' in kwargs:
- min_capacity = kwargs['minCapacity']
- if target_capacity is None and 'targetCapacity' in kwargs:
- target_capacity = kwargs['targetCapacity']
-
- _setter("task_type", task_type)
+ pulumi.set(__self__, "task_type", task_type)
if cron_expression is not None:
- _setter("cron_expression", cron_expression)
+ pulumi.set(__self__, "cron_expression", cron_expression)
if is_enabled is not None:
- _setter("is_enabled", is_enabled)
+ pulumi.set(__self__, "is_enabled", is_enabled)
if max_capacity is not None:
- _setter("max_capacity", max_capacity)
+ pulumi.set(__self__, "max_capacity", max_capacity)
if min_capacity is not None:
- _setter("min_capacity", min_capacity)
+ pulumi.set(__self__, "min_capacity", min_capacity)
if target_capacity is not None:
- _setter("target_capacity", target_capacity)
+ pulumi.set(__self__, "target_capacity", target_capacity)
@property
@pulumi.getter(name="taskType")
@@ -2035,27 +1524,8 @@ def __init__(__self__, *,
:param pulumi.Input[str] region: The region for the group of subnets.
:param pulumi.Input[Sequence[pulumi.Input[str]]] subnet_names: The names of the subnets in the region.
"""
- ElastigroupSubnetArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- region=region,
- subnet_names=subnet_names,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- region: Optional[pulumi.Input[str]] = None,
- subnet_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if region is None:
- raise TypeError("Missing 'region' argument")
- if subnet_names is None and 'subnetNames' in kwargs:
- subnet_names = kwargs['subnetNames']
- if subnet_names is None:
- raise TypeError("Missing 'subnet_names' argument")
-
- _setter("region", region)
- _setter("subnet_names", subnet_names)
+ pulumi.set(__self__, "region", region)
+ pulumi.set(__self__, "subnet_names", subnet_names)
@property
@pulumi.getter
diff --git a/sdk/python/pulumi_spotinst/gcp/elastigroup.py b/sdk/python/pulumi_spotinst/gcp/elastigroup.py
index ba295ac6..a1721cb9 100644
--- a/sdk/python/pulumi_spotinst/gcp/elastigroup.py
+++ b/sdk/python/pulumi_spotinst/gcp/elastigroup.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs
from ._inputs import *
@@ -94,219 +94,80 @@ def __init__(__self__, *,
import pulumi
```
"""
- ElastigroupArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- desired_capacity=desired_capacity,
- auto_healing=auto_healing,
- availability_zones=availability_zones,
- backend_services=backend_services,
- description=description,
- disks=disks,
- draining_timeout=draining_timeout,
- fallback_to_ondemand=fallback_to_ondemand,
- gpu=gpu,
- health_check_grace_period=health_check_grace_period,
- health_check_type=health_check_type,
- instance_name_prefix=instance_name_prefix,
- instance_types_customs=instance_types_customs,
- instance_types_ondemand=instance_types_ondemand,
- instance_types_preemptibles=instance_types_preemptibles,
- integration_docker_swarm=integration_docker_swarm,
- integration_gke=integration_gke,
- ip_forwarding=ip_forwarding,
- labels=labels,
- max_size=max_size,
- metadatas=metadatas,
- min_size=min_size,
- name=name,
- network_interfaces=network_interfaces,
- ondemand_count=ondemand_count,
- preemptible_percentage=preemptible_percentage,
- provisioning_model=provisioning_model,
- scaling_down_policies=scaling_down_policies,
- scaling_up_policies=scaling_up_policies,
- scheduled_tasks=scheduled_tasks,
- service_account=service_account,
- shutdown_script=shutdown_script,
- startup_script=startup_script,
- subnets=subnets,
- tags=tags,
- unhealthy_duration=unhealthy_duration,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- desired_capacity: Optional[pulumi.Input[int]] = None,
- auto_healing: Optional[pulumi.Input[bool]] = None,
- availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- backend_services: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupBackendServiceArgs']]]] = None,
- description: Optional[pulumi.Input[str]] = None,
- disks: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupDiskArgs']]]] = None,
- draining_timeout: Optional[pulumi.Input[int]] = None,
- fallback_to_ondemand: Optional[pulumi.Input[bool]] = None,
- gpu: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupGpuArgs']]]] = None,
- health_check_grace_period: Optional[pulumi.Input[int]] = None,
- health_check_type: Optional[pulumi.Input[str]] = None,
- instance_name_prefix: Optional[pulumi.Input[str]] = None,
- instance_types_customs: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupInstanceTypesCustomArgs']]]] = None,
- instance_types_ondemand: Optional[pulumi.Input[str]] = None,
- instance_types_preemptibles: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- integration_docker_swarm: Optional[pulumi.Input['ElastigroupIntegrationDockerSwarmArgs']] = None,
- integration_gke: Optional[pulumi.Input['ElastigroupIntegrationGkeArgs']] = None,
- ip_forwarding: Optional[pulumi.Input[bool]] = None,
- labels: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupLabelArgs']]]] = None,
- max_size: Optional[pulumi.Input[int]] = None,
- metadatas: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupMetadataArgs']]]] = None,
- min_size: Optional[pulumi.Input[int]] = None,
- name: Optional[pulumi.Input[str]] = None,
- network_interfaces: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceArgs']]]] = None,
- ondemand_count: Optional[pulumi.Input[int]] = None,
- preemptible_percentage: Optional[pulumi.Input[int]] = None,
- provisioning_model: Optional[pulumi.Input[str]] = None,
- scaling_down_policies: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyArgs']]]] = None,
- scaling_up_policies: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyArgs']]]] = None,
- scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScheduledTaskArgs']]]] = None,
- service_account: Optional[pulumi.Input[str]] = None,
- shutdown_script: Optional[pulumi.Input[str]] = None,
- startup_script: Optional[pulumi.Input[str]] = None,
- subnets: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupSubnetArgs']]]] = None,
- tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- unhealthy_duration: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if desired_capacity is None and 'desiredCapacity' in kwargs:
- desired_capacity = kwargs['desiredCapacity']
- if desired_capacity is None:
- raise TypeError("Missing 'desired_capacity' argument")
- if auto_healing is None and 'autoHealing' in kwargs:
- auto_healing = kwargs['autoHealing']
- if availability_zones is None and 'availabilityZones' in kwargs:
- availability_zones = kwargs['availabilityZones']
- if backend_services is None and 'backendServices' in kwargs:
- backend_services = kwargs['backendServices']
- if draining_timeout is None and 'drainingTimeout' in kwargs:
- draining_timeout = kwargs['drainingTimeout']
- if fallback_to_ondemand is None and 'fallbackToOndemand' in kwargs:
- fallback_to_ondemand = kwargs['fallbackToOndemand']
- if health_check_grace_period is None and 'healthCheckGracePeriod' in kwargs:
- health_check_grace_period = kwargs['healthCheckGracePeriod']
- if health_check_type is None and 'healthCheckType' in kwargs:
- health_check_type = kwargs['healthCheckType']
- if instance_name_prefix is None and 'instanceNamePrefix' in kwargs:
- instance_name_prefix = kwargs['instanceNamePrefix']
- if instance_types_customs is None and 'instanceTypesCustoms' in kwargs:
- instance_types_customs = kwargs['instanceTypesCustoms']
- if instance_types_ondemand is None and 'instanceTypesOndemand' in kwargs:
- instance_types_ondemand = kwargs['instanceTypesOndemand']
- if instance_types_preemptibles is None and 'instanceTypesPreemptibles' in kwargs:
- instance_types_preemptibles = kwargs['instanceTypesPreemptibles']
- if integration_docker_swarm is None and 'integrationDockerSwarm' in kwargs:
- integration_docker_swarm = kwargs['integrationDockerSwarm']
- if integration_gke is None and 'integrationGke' in kwargs:
- integration_gke = kwargs['integrationGke']
- if ip_forwarding is None and 'ipForwarding' in kwargs:
- ip_forwarding = kwargs['ipForwarding']
- if max_size is None and 'maxSize' in kwargs:
- max_size = kwargs['maxSize']
- if min_size is None and 'minSize' in kwargs:
- min_size = kwargs['minSize']
- if network_interfaces is None and 'networkInterfaces' in kwargs:
- network_interfaces = kwargs['networkInterfaces']
- if ondemand_count is None and 'ondemandCount' in kwargs:
- ondemand_count = kwargs['ondemandCount']
- if preemptible_percentage is None and 'preemptiblePercentage' in kwargs:
- preemptible_percentage = kwargs['preemptiblePercentage']
- if provisioning_model is None and 'provisioningModel' in kwargs:
- provisioning_model = kwargs['provisioningModel']
- if scaling_down_policies is None and 'scalingDownPolicies' in kwargs:
- scaling_down_policies = kwargs['scalingDownPolicies']
- if scaling_up_policies is None and 'scalingUpPolicies' in kwargs:
- scaling_up_policies = kwargs['scalingUpPolicies']
- if scheduled_tasks is None and 'scheduledTasks' in kwargs:
- scheduled_tasks = kwargs['scheduledTasks']
- if service_account is None and 'serviceAccount' in kwargs:
- service_account = kwargs['serviceAccount']
- if shutdown_script is None and 'shutdownScript' in kwargs:
- shutdown_script = kwargs['shutdownScript']
- if startup_script is None and 'startupScript' in kwargs:
- startup_script = kwargs['startupScript']
- if unhealthy_duration is None and 'unhealthyDuration' in kwargs:
- unhealthy_duration = kwargs['unhealthyDuration']
-
- _setter("desired_capacity", desired_capacity)
+ pulumi.set(__self__, "desired_capacity", desired_capacity)
if auto_healing is not None:
- _setter("auto_healing", auto_healing)
+ pulumi.set(__self__, "auto_healing", auto_healing)
if availability_zones is not None:
warnings.warn("""This field will soon be handled by Region in Subnets""", DeprecationWarning)
pulumi.log.warn("""availability_zones is deprecated: This field will soon be handled by Region in Subnets""")
if availability_zones is not None:
- _setter("availability_zones", availability_zones)
+ pulumi.set(__self__, "availability_zones", availability_zones)
if backend_services is not None:
- _setter("backend_services", backend_services)
+ pulumi.set(__self__, "backend_services", backend_services)
if description is not None:
- _setter("description", description)
+ pulumi.set(__self__, "description", description)
if disks is not None:
- _setter("disks", disks)
+ pulumi.set(__self__, "disks", disks)
if draining_timeout is not None:
- _setter("draining_timeout", draining_timeout)
+ pulumi.set(__self__, "draining_timeout", draining_timeout)
if fallback_to_ondemand is not None:
- _setter("fallback_to_ondemand", fallback_to_ondemand)
+ pulumi.set(__self__, "fallback_to_ondemand", fallback_to_ondemand)
if gpu is not None:
- _setter("gpu", gpu)
+ pulumi.set(__self__, "gpu", gpu)
if health_check_grace_period is not None:
- _setter("health_check_grace_period", health_check_grace_period)
+ pulumi.set(__self__, "health_check_grace_period", health_check_grace_period)
if health_check_type is not None:
- _setter("health_check_type", health_check_type)
+ pulumi.set(__self__, "health_check_type", health_check_type)
if instance_name_prefix is not None:
- _setter("instance_name_prefix", instance_name_prefix)
+ pulumi.set(__self__, "instance_name_prefix", instance_name_prefix)
if instance_types_customs is not None:
- _setter("instance_types_customs", instance_types_customs)
+ pulumi.set(__self__, "instance_types_customs", instance_types_customs)
if instance_types_ondemand is not None:
- _setter("instance_types_ondemand", instance_types_ondemand)
+ pulumi.set(__self__, "instance_types_ondemand", instance_types_ondemand)
if instance_types_preemptibles is not None:
- _setter("instance_types_preemptibles", instance_types_preemptibles)
+ pulumi.set(__self__, "instance_types_preemptibles", instance_types_preemptibles)
if integration_docker_swarm is not None:
- _setter("integration_docker_swarm", integration_docker_swarm)
+ pulumi.set(__self__, "integration_docker_swarm", integration_docker_swarm)
if integration_gke is not None:
- _setter("integration_gke", integration_gke)
+ pulumi.set(__self__, "integration_gke", integration_gke)
if ip_forwarding is not None:
- _setter("ip_forwarding", ip_forwarding)
+ pulumi.set(__self__, "ip_forwarding", ip_forwarding)
if labels is not None:
- _setter("labels", labels)
+ pulumi.set(__self__, "labels", labels)
if max_size is not None:
- _setter("max_size", max_size)
+ pulumi.set(__self__, "max_size", max_size)
if metadatas is not None:
- _setter("metadatas", metadatas)
+ pulumi.set(__self__, "metadatas", metadatas)
if min_size is not None:
- _setter("min_size", min_size)
+ pulumi.set(__self__, "min_size", min_size)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if network_interfaces is not None:
- _setter("network_interfaces", network_interfaces)
+ pulumi.set(__self__, "network_interfaces", network_interfaces)
if ondemand_count is not None:
- _setter("ondemand_count", ondemand_count)
+ pulumi.set(__self__, "ondemand_count", ondemand_count)
if preemptible_percentage is not None:
- _setter("preemptible_percentage", preemptible_percentage)
+ pulumi.set(__self__, "preemptible_percentage", preemptible_percentage)
if provisioning_model is not None:
- _setter("provisioning_model", provisioning_model)
+ pulumi.set(__self__, "provisioning_model", provisioning_model)
if scaling_down_policies is not None:
- _setter("scaling_down_policies", scaling_down_policies)
+ pulumi.set(__self__, "scaling_down_policies", scaling_down_policies)
if scaling_up_policies is not None:
- _setter("scaling_up_policies", scaling_up_policies)
+ pulumi.set(__self__, "scaling_up_policies", scaling_up_policies)
if scheduled_tasks is not None:
- _setter("scheduled_tasks", scheduled_tasks)
+ pulumi.set(__self__, "scheduled_tasks", scheduled_tasks)
if service_account is not None:
- _setter("service_account", service_account)
+ pulumi.set(__self__, "service_account", service_account)
if shutdown_script is not None:
- _setter("shutdown_script", shutdown_script)
+ pulumi.set(__self__, "shutdown_script", shutdown_script)
if startup_script is not None:
- _setter("startup_script", startup_script)
+ pulumi.set(__self__, "startup_script", startup_script)
if subnets is not None:
- _setter("subnets", subnets)
+ pulumi.set(__self__, "subnets", subnets)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
if unhealthy_duration is not None:
- _setter("unhealthy_duration", unhealthy_duration)
+ pulumi.set(__self__, "unhealthy_duration", unhealthy_duration)
@property
@pulumi.getter(name="desiredCapacity")
@@ -818,218 +679,81 @@ def __init__(__self__, *,
import pulumi
```
"""
- _ElastigroupState._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- auto_healing=auto_healing,
- availability_zones=availability_zones,
- backend_services=backend_services,
- description=description,
- desired_capacity=desired_capacity,
- disks=disks,
- draining_timeout=draining_timeout,
- fallback_to_ondemand=fallback_to_ondemand,
- gpu=gpu,
- health_check_grace_period=health_check_grace_period,
- health_check_type=health_check_type,
- instance_name_prefix=instance_name_prefix,
- instance_types_customs=instance_types_customs,
- instance_types_ondemand=instance_types_ondemand,
- instance_types_preemptibles=instance_types_preemptibles,
- integration_docker_swarm=integration_docker_swarm,
- integration_gke=integration_gke,
- ip_forwarding=ip_forwarding,
- labels=labels,
- max_size=max_size,
- metadatas=metadatas,
- min_size=min_size,
- name=name,
- network_interfaces=network_interfaces,
- ondemand_count=ondemand_count,
- preemptible_percentage=preemptible_percentage,
- provisioning_model=provisioning_model,
- scaling_down_policies=scaling_down_policies,
- scaling_up_policies=scaling_up_policies,
- scheduled_tasks=scheduled_tasks,
- service_account=service_account,
- shutdown_script=shutdown_script,
- startup_script=startup_script,
- subnets=subnets,
- tags=tags,
- unhealthy_duration=unhealthy_duration,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- auto_healing: Optional[pulumi.Input[bool]] = None,
- availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- backend_services: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupBackendServiceArgs']]]] = None,
- description: Optional[pulumi.Input[str]] = None,
- desired_capacity: Optional[pulumi.Input[int]] = None,
- disks: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupDiskArgs']]]] = None,
- draining_timeout: Optional[pulumi.Input[int]] = None,
- fallback_to_ondemand: Optional[pulumi.Input[bool]] = None,
- gpu: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupGpuArgs']]]] = None,
- health_check_grace_period: Optional[pulumi.Input[int]] = None,
- health_check_type: Optional[pulumi.Input[str]] = None,
- instance_name_prefix: Optional[pulumi.Input[str]] = None,
- instance_types_customs: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupInstanceTypesCustomArgs']]]] = None,
- instance_types_ondemand: Optional[pulumi.Input[str]] = None,
- instance_types_preemptibles: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- integration_docker_swarm: Optional[pulumi.Input['ElastigroupIntegrationDockerSwarmArgs']] = None,
- integration_gke: Optional[pulumi.Input['ElastigroupIntegrationGkeArgs']] = None,
- ip_forwarding: Optional[pulumi.Input[bool]] = None,
- labels: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupLabelArgs']]]] = None,
- max_size: Optional[pulumi.Input[int]] = None,
- metadatas: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupMetadataArgs']]]] = None,
- min_size: Optional[pulumi.Input[int]] = None,
- name: Optional[pulumi.Input[str]] = None,
- network_interfaces: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceArgs']]]] = None,
- ondemand_count: Optional[pulumi.Input[int]] = None,
- preemptible_percentage: Optional[pulumi.Input[int]] = None,
- provisioning_model: Optional[pulumi.Input[str]] = None,
- scaling_down_policies: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyArgs']]]] = None,
- scaling_up_policies: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyArgs']]]] = None,
- scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScheduledTaskArgs']]]] = None,
- service_account: Optional[pulumi.Input[str]] = None,
- shutdown_script: Optional[pulumi.Input[str]] = None,
- startup_script: Optional[pulumi.Input[str]] = None,
- subnets: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupSubnetArgs']]]] = None,
- tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- unhealthy_duration: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if auto_healing is None and 'autoHealing' in kwargs:
- auto_healing = kwargs['autoHealing']
- if availability_zones is None and 'availabilityZones' in kwargs:
- availability_zones = kwargs['availabilityZones']
- if backend_services is None and 'backendServices' in kwargs:
- backend_services = kwargs['backendServices']
- if desired_capacity is None and 'desiredCapacity' in kwargs:
- desired_capacity = kwargs['desiredCapacity']
- if draining_timeout is None and 'drainingTimeout' in kwargs:
- draining_timeout = kwargs['drainingTimeout']
- if fallback_to_ondemand is None and 'fallbackToOndemand' in kwargs:
- fallback_to_ondemand = kwargs['fallbackToOndemand']
- if health_check_grace_period is None and 'healthCheckGracePeriod' in kwargs:
- health_check_grace_period = kwargs['healthCheckGracePeriod']
- if health_check_type is None and 'healthCheckType' in kwargs:
- health_check_type = kwargs['healthCheckType']
- if instance_name_prefix is None and 'instanceNamePrefix' in kwargs:
- instance_name_prefix = kwargs['instanceNamePrefix']
- if instance_types_customs is None and 'instanceTypesCustoms' in kwargs:
- instance_types_customs = kwargs['instanceTypesCustoms']
- if instance_types_ondemand is None and 'instanceTypesOndemand' in kwargs:
- instance_types_ondemand = kwargs['instanceTypesOndemand']
- if instance_types_preemptibles is None and 'instanceTypesPreemptibles' in kwargs:
- instance_types_preemptibles = kwargs['instanceTypesPreemptibles']
- if integration_docker_swarm is None and 'integrationDockerSwarm' in kwargs:
- integration_docker_swarm = kwargs['integrationDockerSwarm']
- if integration_gke is None and 'integrationGke' in kwargs:
- integration_gke = kwargs['integrationGke']
- if ip_forwarding is None and 'ipForwarding' in kwargs:
- ip_forwarding = kwargs['ipForwarding']
- if max_size is None and 'maxSize' in kwargs:
- max_size = kwargs['maxSize']
- if min_size is None and 'minSize' in kwargs:
- min_size = kwargs['minSize']
- if network_interfaces is None and 'networkInterfaces' in kwargs:
- network_interfaces = kwargs['networkInterfaces']
- if ondemand_count is None and 'ondemandCount' in kwargs:
- ondemand_count = kwargs['ondemandCount']
- if preemptible_percentage is None and 'preemptiblePercentage' in kwargs:
- preemptible_percentage = kwargs['preemptiblePercentage']
- if provisioning_model is None and 'provisioningModel' in kwargs:
- provisioning_model = kwargs['provisioningModel']
- if scaling_down_policies is None and 'scalingDownPolicies' in kwargs:
- scaling_down_policies = kwargs['scalingDownPolicies']
- if scaling_up_policies is None and 'scalingUpPolicies' in kwargs:
- scaling_up_policies = kwargs['scalingUpPolicies']
- if scheduled_tasks is None and 'scheduledTasks' in kwargs:
- scheduled_tasks = kwargs['scheduledTasks']
- if service_account is None and 'serviceAccount' in kwargs:
- service_account = kwargs['serviceAccount']
- if shutdown_script is None and 'shutdownScript' in kwargs:
- shutdown_script = kwargs['shutdownScript']
- if startup_script is None and 'startupScript' in kwargs:
- startup_script = kwargs['startupScript']
- if unhealthy_duration is None and 'unhealthyDuration' in kwargs:
- unhealthy_duration = kwargs['unhealthyDuration']
-
if auto_healing is not None:
- _setter("auto_healing", auto_healing)
+ pulumi.set(__self__, "auto_healing", auto_healing)
if availability_zones is not None:
warnings.warn("""This field will soon be handled by Region in Subnets""", DeprecationWarning)
pulumi.log.warn("""availability_zones is deprecated: This field will soon be handled by Region in Subnets""")
if availability_zones is not None:
- _setter("availability_zones", availability_zones)
+ pulumi.set(__self__, "availability_zones", availability_zones)
if backend_services is not None:
- _setter("backend_services", backend_services)
+ pulumi.set(__self__, "backend_services", backend_services)
if description is not None:
- _setter("description", description)
+ pulumi.set(__self__, "description", description)
if desired_capacity is not None:
- _setter("desired_capacity", desired_capacity)
+ pulumi.set(__self__, "desired_capacity", desired_capacity)
if disks is not None:
- _setter("disks", disks)
+ pulumi.set(__self__, "disks", disks)
if draining_timeout is not None:
- _setter("draining_timeout", draining_timeout)
+ pulumi.set(__self__, "draining_timeout", draining_timeout)
if fallback_to_ondemand is not None:
- _setter("fallback_to_ondemand", fallback_to_ondemand)
+ pulumi.set(__self__, "fallback_to_ondemand", fallback_to_ondemand)
if gpu is not None:
- _setter("gpu", gpu)
+ pulumi.set(__self__, "gpu", gpu)
if health_check_grace_period is not None:
- _setter("health_check_grace_period", health_check_grace_period)
+ pulumi.set(__self__, "health_check_grace_period", health_check_grace_period)
if health_check_type is not None:
- _setter("health_check_type", health_check_type)
+ pulumi.set(__self__, "health_check_type", health_check_type)
if instance_name_prefix is not None:
- _setter("instance_name_prefix", instance_name_prefix)
+ pulumi.set(__self__, "instance_name_prefix", instance_name_prefix)
if instance_types_customs is not None:
- _setter("instance_types_customs", instance_types_customs)
+ pulumi.set(__self__, "instance_types_customs", instance_types_customs)
if instance_types_ondemand is not None:
- _setter("instance_types_ondemand", instance_types_ondemand)
+ pulumi.set(__self__, "instance_types_ondemand", instance_types_ondemand)
if instance_types_preemptibles is not None:
- _setter("instance_types_preemptibles", instance_types_preemptibles)
+ pulumi.set(__self__, "instance_types_preemptibles", instance_types_preemptibles)
if integration_docker_swarm is not None:
- _setter("integration_docker_swarm", integration_docker_swarm)
+ pulumi.set(__self__, "integration_docker_swarm", integration_docker_swarm)
if integration_gke is not None:
- _setter("integration_gke", integration_gke)
+ pulumi.set(__self__, "integration_gke", integration_gke)
if ip_forwarding is not None:
- _setter("ip_forwarding", ip_forwarding)
+ pulumi.set(__self__, "ip_forwarding", ip_forwarding)
if labels is not None:
- _setter("labels", labels)
+ pulumi.set(__self__, "labels", labels)
if max_size is not None:
- _setter("max_size", max_size)
+ pulumi.set(__self__, "max_size", max_size)
if metadatas is not None:
- _setter("metadatas", metadatas)
+ pulumi.set(__self__, "metadatas", metadatas)
if min_size is not None:
- _setter("min_size", min_size)
+ pulumi.set(__self__, "min_size", min_size)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if network_interfaces is not None:
- _setter("network_interfaces", network_interfaces)
+ pulumi.set(__self__, "network_interfaces", network_interfaces)
if ondemand_count is not None:
- _setter("ondemand_count", ondemand_count)
+ pulumi.set(__self__, "ondemand_count", ondemand_count)
if preemptible_percentage is not None:
- _setter("preemptible_percentage", preemptible_percentage)
+ pulumi.set(__self__, "preemptible_percentage", preemptible_percentage)
if provisioning_model is not None:
- _setter("provisioning_model", provisioning_model)
+ pulumi.set(__self__, "provisioning_model", provisioning_model)
if scaling_down_policies is not None:
- _setter("scaling_down_policies", scaling_down_policies)
+ pulumi.set(__self__, "scaling_down_policies", scaling_down_policies)
if scaling_up_policies is not None:
- _setter("scaling_up_policies", scaling_up_policies)
+ pulumi.set(__self__, "scaling_up_policies", scaling_up_policies)
if scheduled_tasks is not None:
- _setter("scheduled_tasks", scheduled_tasks)
+ pulumi.set(__self__, "scheduled_tasks", scheduled_tasks)
if service_account is not None:
- _setter("service_account", service_account)
+ pulumi.set(__self__, "service_account", service_account)
if shutdown_script is not None:
- _setter("shutdown_script", shutdown_script)
+ pulumi.set(__self__, "shutdown_script", shutdown_script)
if startup_script is not None:
- _setter("startup_script", startup_script)
+ pulumi.set(__self__, "startup_script", startup_script)
if subnets is not None:
- _setter("subnets", subnets)
+ pulumi.set(__self__, "subnets", subnets)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
if unhealthy_duration is not None:
- _setter("unhealthy_duration", unhealthy_duration)
+ pulumi.set(__self__, "unhealthy_duration", unhealthy_duration)
@property
@pulumi.getter(name="autoHealing")
@@ -1750,10 +1474,6 @@ def __init__(__self__, resource_name: str, *args, **kwargs):
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
- kwargs = kwargs or {}
- def _setter(key, value):
- kwargs[key] = value
- ElastigroupArgs._configure(_setter, **kwargs)
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
@@ -1821,9 +1541,7 @@ def _internal_init(__self__,
__props__.__dict__["instance_types_customs"] = instance_types_customs
__props__.__dict__["instance_types_ondemand"] = instance_types_ondemand
__props__.__dict__["instance_types_preemptibles"] = instance_types_preemptibles
- integration_docker_swarm = _utilities.configure(integration_docker_swarm, ElastigroupIntegrationDockerSwarmArgs, True)
__props__.__dict__["integration_docker_swarm"] = integration_docker_swarm
- integration_gke = _utilities.configure(integration_gke, ElastigroupIntegrationGkeArgs, True)
__props__.__dict__["integration_gke"] = integration_gke
__props__.__dict__["ip_forwarding"] = ip_forwarding
__props__.__dict__["labels"] = labels
diff --git a/sdk/python/pulumi_spotinst/gcp/outputs.py b/sdk/python/pulumi_spotinst/gcp/outputs.py
index b27f41aa..2d2fd473 100644
--- a/sdk/python/pulumi_spotinst/gcp/outputs.py
+++ b/sdk/python/pulumi_spotinst/gcp/outputs.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs
@@ -69,38 +69,13 @@ def __init__(__self__, *,
:param Sequence['ElastigroupBackendServiceNamedPortArgs'] named_ports: Describes a named port and a list of ports.
:param str scheme: Use when `location_type` is "regional". Set the traffic for the backend service to either between the instances in the vpc or to traffic from the internet. Valid values: `INTERNAL`, `EXTERNAL`.
"""
- ElastigroupBackendService._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- service_name=service_name,
- location_type=location_type,
- named_ports=named_ports,
- scheme=scheme,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- service_name: Optional[str] = None,
- location_type: Optional[str] = None,
- named_ports: Optional[Sequence['outputs.ElastigroupBackendServiceNamedPort']] = None,
- scheme: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if service_name is None and 'serviceName' in kwargs:
- service_name = kwargs['serviceName']
- if service_name is None:
- raise TypeError("Missing 'service_name' argument")
- if location_type is None and 'locationType' in kwargs:
- location_type = kwargs['locationType']
- if named_ports is None and 'namedPorts' in kwargs:
- named_ports = kwargs['namedPorts']
-
- _setter("service_name", service_name)
+ pulumi.set(__self__, "service_name", service_name)
if location_type is not None:
- _setter("location_type", location_type)
+ pulumi.set(__self__, "location_type", location_type)
if named_ports is not None:
- _setter("named_ports", named_ports)
+ pulumi.set(__self__, "named_ports", named_ports)
if scheme is not None:
- _setter("scheme", scheme)
+ pulumi.set(__self__, "scheme", scheme)
@property
@pulumi.getter(name="serviceName")
@@ -150,25 +125,8 @@ def __init__(__self__, *,
import pulumi
```
"""
- ElastigroupBackendServiceNamedPort._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- ports=ports,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[str] = None,
- ports: Optional[Sequence[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
- if ports is None:
- raise TypeError("Missing 'ports' argument")
-
- _setter("name", name)
- _setter("ports", ports)
+ pulumi.set(__self__, "name", name)
+ pulumi.set(__self__, "ports", ports)
@property
@pulumi.getter
@@ -235,53 +193,22 @@ def __init__(__self__, *,
:param str source: Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.
:param str type: Specifies the type of disk, either SCRATCH or PERSISTENT.
"""
- ElastigroupDisk._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- auto_delete=auto_delete,
- boot=boot,
- device_name=device_name,
- initialize_params=initialize_params,
- interface=interface,
- mode=mode,
- source=source,
- type=type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- auto_delete: Optional[bool] = None,
- boot: Optional[bool] = None,
- device_name: Optional[str] = None,
- initialize_params: Optional[Sequence['outputs.ElastigroupDiskInitializeParam']] = None,
- interface: Optional[str] = None,
- mode: Optional[str] = None,
- source: Optional[str] = None,
- type: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if auto_delete is None and 'autoDelete' in kwargs:
- auto_delete = kwargs['autoDelete']
- if device_name is None and 'deviceName' in kwargs:
- device_name = kwargs['deviceName']
- if initialize_params is None and 'initializeParams' in kwargs:
- initialize_params = kwargs['initializeParams']
-
if auto_delete is not None:
- _setter("auto_delete", auto_delete)
+ pulumi.set(__self__, "auto_delete", auto_delete)
if boot is not None:
- _setter("boot", boot)
+ pulumi.set(__self__, "boot", boot)
if device_name is not None:
- _setter("device_name", device_name)
+ pulumi.set(__self__, "device_name", device_name)
if initialize_params is not None:
- _setter("initialize_params", initialize_params)
+ pulumi.set(__self__, "initialize_params", initialize_params)
if interface is not None:
- _setter("interface", interface)
+ pulumi.set(__self__, "interface", interface)
if mode is not None:
- _setter("mode", mode)
+ pulumi.set(__self__, "mode", mode)
if source is not None:
- _setter("source", source)
+ pulumi.set(__self__, "source", source)
if type is not None:
- _setter("type", type)
+ pulumi.set(__self__, "type", type)
@property
@pulumi.getter(name="autoDelete")
@@ -386,34 +313,11 @@ def __init__(__self__, *,
:param str disk_size_gb: Specifies disk size in gigabytes. Must be in increments of 2.
:param str disk_type: Specifies the disk type to use to create the instance. Valid values: pd-ssd, local-ssd.
"""
- ElastigroupDiskInitializeParam._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- source_image=source_image,
- disk_size_gb=disk_size_gb,
- disk_type=disk_type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- source_image: Optional[str] = None,
- disk_size_gb: Optional[str] = None,
- disk_type: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if source_image is None and 'sourceImage' in kwargs:
- source_image = kwargs['sourceImage']
- if source_image is None:
- raise TypeError("Missing 'source_image' argument")
- if disk_size_gb is None and 'diskSizeGb' in kwargs:
- disk_size_gb = kwargs['diskSizeGb']
- if disk_type is None and 'diskType' in kwargs:
- disk_type = kwargs['diskType']
-
- _setter("source_image", source_image)
+ pulumi.set(__self__, "source_image", source_image)
if disk_size_gb is not None:
- _setter("disk_size_gb", disk_size_gb)
+ pulumi.set(__self__, "disk_size_gb", disk_size_gb)
if disk_type is not None:
- _setter("disk_type", disk_type)
+ pulumi.set(__self__, "disk_type", disk_type)
@property
@pulumi.getter(name="sourceImage")
@@ -461,25 +365,8 @@ def __init__(__self__, *,
```
:param str type: The type of GPU instance. Valid values: `nvidia-tesla-v100`, `nvidia-tesla-p100`, `nvidia-tesla-k80`.
"""
- ElastigroupGpu._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- count=count,
- type=type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- count: Optional[int] = None,
- type: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if count is None:
- raise TypeError("Missing 'count' argument")
- if type is None:
- raise TypeError("Missing 'type' argument")
-
- _setter("count", count)
- _setter("type", type)
+ pulumi.set(__self__, "count", count)
+ pulumi.set(__self__, "type", type)
@property
@pulumi.getter
@@ -529,27 +416,8 @@ def __init__(__self__, *,
"""
:param int memory_gib: The memory (in GiB) in the custom instance types. GCP has a number of limitations on accepted memory values.For more information, see the GCP documentation (here.)[https://cloud.google.com/compute/docs/instances/creating-instance-with-custom-machine-type#specifications]
"""
- ElastigroupInstanceTypesCustom._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- memory_gib=memory_gib,
- vcpu=vcpu,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- memory_gib: Optional[int] = None,
- vcpu: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if memory_gib is None and 'memoryGib' in kwargs:
- memory_gib = kwargs['memoryGib']
- if memory_gib is None:
- raise TypeError("Missing 'memory_gib' argument")
- if vcpu is None:
- raise TypeError("Missing 'vcpu' argument")
-
- _setter("memory_gib", memory_gib)
- _setter("vcpu", vcpu)
+ pulumi.set(__self__, "memory_gib", memory_gib)
+ pulumi.set(__self__, "vcpu", vcpu)
@property
@pulumi.getter(name="memoryGib")
@@ -599,29 +467,8 @@ def __init__(__self__, *,
import pulumi
```
"""
- ElastigroupIntegrationDockerSwarm._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- master_host=master_host,
- master_port=master_port,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- master_host: Optional[str] = None,
- master_port: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if master_host is None and 'masterHost' in kwargs:
- master_host = kwargs['masterHost']
- if master_host is None:
- raise TypeError("Missing 'master_host' argument")
- if master_port is None and 'masterPort' in kwargs:
- master_port = kwargs['masterPort']
- if master_port is None:
- raise TypeError("Missing 'master_port' argument")
-
- _setter("master_host", master_host)
- _setter("master_port", master_port)
+ pulumi.set(__self__, "master_host", master_host)
+ pulumi.set(__self__, "master_port", master_port)
@property
@pulumi.getter(name="masterHost")
@@ -689,67 +536,24 @@ def __init__(__self__, *,
autoscale_labels: Optional[Sequence['outputs.ElastigroupIntegrationGkeAutoscaleLabel']] = None,
cluster_id: Optional[str] = None,
location: Optional[str] = None):
- ElastigroupIntegrationGke._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- auto_update=auto_update,
- autoscale_cooldown=autoscale_cooldown,
- autoscale_down=autoscale_down,
- autoscale_headroom=autoscale_headroom,
- autoscale_is_auto_config=autoscale_is_auto_config,
- autoscale_is_enabled=autoscale_is_enabled,
- autoscale_labels=autoscale_labels,
- cluster_id=cluster_id,
- location=location,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- auto_update: Optional[bool] = None,
- autoscale_cooldown: Optional[int] = None,
- autoscale_down: Optional['outputs.ElastigroupIntegrationGkeAutoscaleDown'] = None,
- autoscale_headroom: Optional['outputs.ElastigroupIntegrationGkeAutoscaleHeadroom'] = None,
- autoscale_is_auto_config: Optional[bool] = None,
- autoscale_is_enabled: Optional[bool] = None,
- autoscale_labels: Optional[Sequence['outputs.ElastigroupIntegrationGkeAutoscaleLabel']] = None,
- cluster_id: Optional[str] = None,
- location: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if auto_update is None and 'autoUpdate' in kwargs:
- auto_update = kwargs['autoUpdate']
- if autoscale_cooldown is None and 'autoscaleCooldown' in kwargs:
- autoscale_cooldown = kwargs['autoscaleCooldown']
- if autoscale_down is None and 'autoscaleDown' in kwargs:
- autoscale_down = kwargs['autoscaleDown']
- if autoscale_headroom is None and 'autoscaleHeadroom' in kwargs:
- autoscale_headroom = kwargs['autoscaleHeadroom']
- if autoscale_is_auto_config is None and 'autoscaleIsAutoConfig' in kwargs:
- autoscale_is_auto_config = kwargs['autoscaleIsAutoConfig']
- if autoscale_is_enabled is None and 'autoscaleIsEnabled' in kwargs:
- autoscale_is_enabled = kwargs['autoscaleIsEnabled']
- if autoscale_labels is None and 'autoscaleLabels' in kwargs:
- autoscale_labels = kwargs['autoscaleLabels']
- if cluster_id is None and 'clusterId' in kwargs:
- cluster_id = kwargs['clusterId']
-
if auto_update is not None:
- _setter("auto_update", auto_update)
+ pulumi.set(__self__, "auto_update", auto_update)
if autoscale_cooldown is not None:
- _setter("autoscale_cooldown", autoscale_cooldown)
+ pulumi.set(__self__, "autoscale_cooldown", autoscale_cooldown)
if autoscale_down is not None:
- _setter("autoscale_down", autoscale_down)
+ pulumi.set(__self__, "autoscale_down", autoscale_down)
if autoscale_headroom is not None:
- _setter("autoscale_headroom", autoscale_headroom)
+ pulumi.set(__self__, "autoscale_headroom", autoscale_headroom)
if autoscale_is_auto_config is not None:
- _setter("autoscale_is_auto_config", autoscale_is_auto_config)
+ pulumi.set(__self__, "autoscale_is_auto_config", autoscale_is_auto_config)
if autoscale_is_enabled is not None:
- _setter("autoscale_is_enabled", autoscale_is_enabled)
+ pulumi.set(__self__, "autoscale_is_enabled", autoscale_is_enabled)
if autoscale_labels is not None:
- _setter("autoscale_labels", autoscale_labels)
+ pulumi.set(__self__, "autoscale_labels", autoscale_labels)
if cluster_id is not None:
- _setter("cluster_id", cluster_id)
+ pulumi.set(__self__, "cluster_id", cluster_id)
if location is not None:
- _setter("location", location)
+ pulumi.set(__self__, "location", location)
@property
@pulumi.getter(name="autoUpdate")
@@ -821,21 +625,8 @@ def __init__(__self__, *,
"""
:param int evaluation_periods: Number of consecutive periods in which the threshold must be met in order to trigger a scaling action.
"""
- ElastigroupIntegrationGkeAutoscaleDown._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- evaluation_periods=evaluation_periods,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- evaluation_periods: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
-
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
@property
@pulumi.getter(name="evaluationPeriods")
@@ -873,33 +664,12 @@ def __init__(__self__, *,
cpu_per_unit: Optional[int] = None,
memory_per_unit: Optional[int] = None,
num_of_units: Optional[int] = None):
- ElastigroupIntegrationGkeAutoscaleHeadroom._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cpu_per_unit=cpu_per_unit,
- memory_per_unit=memory_per_unit,
- num_of_units=num_of_units,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cpu_per_unit: Optional[int] = None,
- memory_per_unit: Optional[int] = None,
- num_of_units: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cpu_per_unit is None and 'cpuPerUnit' in kwargs:
- cpu_per_unit = kwargs['cpuPerUnit']
- if memory_per_unit is None and 'memoryPerUnit' in kwargs:
- memory_per_unit = kwargs['memoryPerUnit']
- if num_of_units is None and 'numOfUnits' in kwargs:
- num_of_units = kwargs['numOfUnits']
-
if cpu_per_unit is not None:
- _setter("cpu_per_unit", cpu_per_unit)
+ pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
if memory_per_unit is not None:
- _setter("memory_per_unit", memory_per_unit)
+ pulumi.set(__self__, "memory_per_unit", memory_per_unit)
if num_of_units is not None:
- _setter("num_of_units", num_of_units)
+ pulumi.set(__self__, "num_of_units", num_of_units)
@property
@pulumi.getter(name="cpuPerUnit")
@@ -926,25 +696,8 @@ def __init__(__self__, *,
:param str key: Labels key.
:param str value: Labels value.
"""
- ElastigroupIntegrationGkeAutoscaleLabel._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -972,25 +725,8 @@ def __init__(__self__, *,
:param str key: Labels key.
:param str value: Labels value.
"""
- ElastigroupLabel._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -1018,25 +754,8 @@ def __init__(__self__, *,
:param str key: Labels key.
:param str value: Labels value.
"""
- ElastigroupMetadata._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -1084,32 +803,11 @@ def __init__(__self__, *,
:param str network: Network resource for this group.
:param Sequence['ElastigroupNetworkInterfaceAccessConfigArgs'] access_configs: Array of configurations.
"""
- ElastigroupNetworkInterface._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- network=network,
- access_configs=access_configs,
- alias_ip_ranges=alias_ip_ranges,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- network: Optional[str] = None,
- access_configs: Optional[Sequence['outputs.ElastigroupNetworkInterfaceAccessConfig']] = None,
- alias_ip_ranges: Optional[Sequence['outputs.ElastigroupNetworkInterfaceAliasIpRange']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if network is None:
- raise TypeError("Missing 'network' argument")
- if access_configs is None and 'accessConfigs' in kwargs:
- access_configs = kwargs['accessConfigs']
- if alias_ip_ranges is None and 'aliasIpRanges' in kwargs:
- alias_ip_ranges = kwargs['aliasIpRanges']
-
- _setter("network", network)
+ pulumi.set(__self__, "network", network)
if access_configs is not None:
- _setter("access_configs", access_configs)
+ pulumi.set(__self__, "access_configs", access_configs)
if alias_ip_ranges is not None:
- _setter("alias_ip_ranges", alias_ip_ranges)
+ pulumi.set(__self__, "alias_ip_ranges", alias_ip_ranges)
@property
@pulumi.getter
@@ -1142,23 +840,10 @@ def __init__(__self__, *,
:param str name: The group name.
:param str type: Specifies the type of disk, either SCRATCH or PERSISTENT.
"""
- ElastigroupNetworkInterfaceAccessConfig._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- type=type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[str] = None,
- type: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if type is not None:
- _setter("type", type)
+ pulumi.set(__self__, "type", type)
@property
@pulumi.getter
@@ -1201,29 +886,8 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
ip_cidr_range: str,
subnetwork_range_name: str):
- ElastigroupNetworkInterfaceAliasIpRange._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- ip_cidr_range=ip_cidr_range,
- subnetwork_range_name=subnetwork_range_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- ip_cidr_range: Optional[str] = None,
- subnetwork_range_name: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if ip_cidr_range is None and 'ipCidrRange' in kwargs:
- ip_cidr_range = kwargs['ipCidrRange']
- if ip_cidr_range is None:
- raise TypeError("Missing 'ip_cidr_range' argument")
- if subnetwork_range_name is None and 'subnetworkRangeName' in kwargs:
- subnetwork_range_name = kwargs['subnetworkRangeName']
- if subnetwork_range_name is None:
- raise TypeError("Missing 'subnetwork_range_name' argument")
-
- _setter("ip_cidr_range", ip_cidr_range)
- _setter("subnetwork_range_name", subnetwork_range_name)
+ pulumi.set(__self__, "ip_cidr_range", ip_cidr_range)
+ pulumi.set(__self__, "subnetwork_range_name", subnetwork_range_name)
@property
@pulumi.getter(name="ipCidrRange")
@@ -1290,84 +954,29 @@ def __init__(__self__, *,
:param str source: Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.
:param str statistic: Statistic by which to evaluate the selected metric. Valid values: "AVERAGE", "SAMPLE_COUNT", "SUM", "MINIMUM", "MAXIMUM", "PERCENTILE", "COUNT".
"""
- ElastigroupScalingDownPolicy._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- metric_name=metric_name,
- namespace=namespace,
- policy_name=policy_name,
- threshold=threshold,
- unit=unit,
- action_type=action_type,
- adjustment=adjustment,
- cooldown=cooldown,
- dimensions=dimensions,
- evaluation_periods=evaluation_periods,
- operator=operator,
- period=period,
- source=source,
- statistic=statistic,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- metric_name: Optional[str] = None,
- namespace: Optional[str] = None,
- policy_name: Optional[str] = None,
- threshold: Optional[float] = None,
- unit: Optional[str] = None,
- action_type: Optional[str] = None,
- adjustment: Optional[int] = None,
- cooldown: Optional[int] = None,
- dimensions: Optional[Sequence['outputs.ElastigroupScalingDownPolicyDimension']] = None,
- evaluation_periods: Optional[int] = None,
- operator: Optional[str] = None,
- period: Optional[int] = None,
- source: Optional[str] = None,
- statistic: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if metric_name is None and 'metricName' in kwargs:
- metric_name = kwargs['metricName']
- if metric_name is None:
- raise TypeError("Missing 'metric_name' argument")
- if namespace is None:
- raise TypeError("Missing 'namespace' argument")
- if policy_name is None and 'policyName' in kwargs:
- policy_name = kwargs['policyName']
- if policy_name is None:
- raise TypeError("Missing 'policy_name' argument")
- if threshold is None:
- raise TypeError("Missing 'threshold' argument")
- if unit is None:
- raise TypeError("Missing 'unit' argument")
- if action_type is None and 'actionType' in kwargs:
- action_type = kwargs['actionType']
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
-
- _setter("metric_name", metric_name)
- _setter("namespace", namespace)
- _setter("policy_name", policy_name)
- _setter("threshold", threshold)
- _setter("unit", unit)
+ pulumi.set(__self__, "metric_name", metric_name)
+ pulumi.set(__self__, "namespace", namespace)
+ pulumi.set(__self__, "policy_name", policy_name)
+ pulumi.set(__self__, "threshold", threshold)
+ pulumi.set(__self__, "unit", unit)
if action_type is not None:
- _setter("action_type", action_type)
+ pulumi.set(__self__, "action_type", action_type)
if adjustment is not None:
- _setter("adjustment", adjustment)
+ pulumi.set(__self__, "adjustment", adjustment)
if cooldown is not None:
- _setter("cooldown", cooldown)
+ pulumi.set(__self__, "cooldown", cooldown)
if dimensions is not None:
- _setter("dimensions", dimensions)
+ pulumi.set(__self__, "dimensions", dimensions)
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
if operator is not None:
- _setter("operator", operator)
+ pulumi.set(__self__, "operator", operator)
if period is not None:
- _setter("period", period)
+ pulumi.set(__self__, "period", period)
if source is not None:
- _setter("source", source)
+ pulumi.set(__self__, "source", source)
if statistic is not None:
- _setter("statistic", statistic)
+ pulumi.set(__self__, "statistic", statistic)
@property
@pulumi.getter(name="metricName")
@@ -1485,24 +1094,9 @@ def __init__(__self__, *,
:param str name: The group name.
:param str value: Labels value.
"""
- ElastigroupScalingDownPolicyDimension._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
-
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if value is not None:
- _setter("value", value)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -1575,84 +1169,29 @@ def __init__(__self__, *,
:param str source: Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.
:param str statistic: Statistic by which to evaluate the selected metric. Valid values: "AVERAGE", "SAMPLE_COUNT", "SUM", "MINIMUM", "MAXIMUM", "PERCENTILE", "COUNT".
"""
- ElastigroupScalingUpPolicy._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- metric_name=metric_name,
- namespace=namespace,
- policy_name=policy_name,
- threshold=threshold,
- unit=unit,
- action_type=action_type,
- adjustment=adjustment,
- cooldown=cooldown,
- dimensions=dimensions,
- evaluation_periods=evaluation_periods,
- operator=operator,
- period=period,
- source=source,
- statistic=statistic,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- metric_name: Optional[str] = None,
- namespace: Optional[str] = None,
- policy_name: Optional[str] = None,
- threshold: Optional[float] = None,
- unit: Optional[str] = None,
- action_type: Optional[str] = None,
- adjustment: Optional[int] = None,
- cooldown: Optional[int] = None,
- dimensions: Optional[Sequence['outputs.ElastigroupScalingUpPolicyDimension']] = None,
- evaluation_periods: Optional[int] = None,
- operator: Optional[str] = None,
- period: Optional[int] = None,
- source: Optional[str] = None,
- statistic: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if metric_name is None and 'metricName' in kwargs:
- metric_name = kwargs['metricName']
- if metric_name is None:
- raise TypeError("Missing 'metric_name' argument")
- if namespace is None:
- raise TypeError("Missing 'namespace' argument")
- if policy_name is None and 'policyName' in kwargs:
- policy_name = kwargs['policyName']
- if policy_name is None:
- raise TypeError("Missing 'policy_name' argument")
- if threshold is None:
- raise TypeError("Missing 'threshold' argument")
- if unit is None:
- raise TypeError("Missing 'unit' argument")
- if action_type is None and 'actionType' in kwargs:
- action_type = kwargs['actionType']
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
-
- _setter("metric_name", metric_name)
- _setter("namespace", namespace)
- _setter("policy_name", policy_name)
- _setter("threshold", threshold)
- _setter("unit", unit)
+ pulumi.set(__self__, "metric_name", metric_name)
+ pulumi.set(__self__, "namespace", namespace)
+ pulumi.set(__self__, "policy_name", policy_name)
+ pulumi.set(__self__, "threshold", threshold)
+ pulumi.set(__self__, "unit", unit)
if action_type is not None:
- _setter("action_type", action_type)
+ pulumi.set(__self__, "action_type", action_type)
if adjustment is not None:
- _setter("adjustment", adjustment)
+ pulumi.set(__self__, "adjustment", adjustment)
if cooldown is not None:
- _setter("cooldown", cooldown)
+ pulumi.set(__self__, "cooldown", cooldown)
if dimensions is not None:
- _setter("dimensions", dimensions)
+ pulumi.set(__self__, "dimensions", dimensions)
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
if operator is not None:
- _setter("operator", operator)
+ pulumi.set(__self__, "operator", operator)
if period is not None:
- _setter("period", period)
+ pulumi.set(__self__, "period", period)
if source is not None:
- _setter("source", source)
+ pulumi.set(__self__, "source", source)
if statistic is not None:
- _setter("statistic", statistic)
+ pulumi.set(__self__, "statistic", statistic)
@property
@pulumi.getter(name="metricName")
@@ -1770,24 +1309,9 @@ def __init__(__self__, *,
:param str name: The group name.
:param str value: Labels value.
"""
- ElastigroupScalingUpPolicyDimension._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
-
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if value is not None:
- _setter("value", value)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -1856,52 +1380,17 @@ def __init__(__self__, *,
:param str min_capacity: The minimum number of instances the group should have.
:param str target_capacity: The desired number of instances the group should have.
"""
- ElastigroupScheduledTask._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- task_type=task_type,
- cron_expression=cron_expression,
- is_enabled=is_enabled,
- max_capacity=max_capacity,
- min_capacity=min_capacity,
- target_capacity=target_capacity,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- task_type: Optional[str] = None,
- cron_expression: Optional[str] = None,
- is_enabled: Optional[bool] = None,
- max_capacity: Optional[str] = None,
- min_capacity: Optional[str] = None,
- target_capacity: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if task_type is None and 'taskType' in kwargs:
- task_type = kwargs['taskType']
- if task_type is None:
- raise TypeError("Missing 'task_type' argument")
- if cron_expression is None and 'cronExpression' in kwargs:
- cron_expression = kwargs['cronExpression']
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
- if max_capacity is None and 'maxCapacity' in kwargs:
- max_capacity = kwargs['maxCapacity']
- if min_capacity is None and 'minCapacity' in kwargs:
- min_capacity = kwargs['minCapacity']
- if target_capacity is None and 'targetCapacity' in kwargs:
- target_capacity = kwargs['targetCapacity']
-
- _setter("task_type", task_type)
+ pulumi.set(__self__, "task_type", task_type)
if cron_expression is not None:
- _setter("cron_expression", cron_expression)
+ pulumi.set(__self__, "cron_expression", cron_expression)
if is_enabled is not None:
- _setter("is_enabled", is_enabled)
+ pulumi.set(__self__, "is_enabled", is_enabled)
if max_capacity is not None:
- _setter("max_capacity", max_capacity)
+ pulumi.set(__self__, "max_capacity", max_capacity)
if min_capacity is not None:
- _setter("min_capacity", min_capacity)
+ pulumi.set(__self__, "min_capacity", min_capacity)
if target_capacity is not None:
- _setter("target_capacity", target_capacity)
+ pulumi.set(__self__, "target_capacity", target_capacity)
@property
@pulumi.getter(name="taskType")
@@ -1984,27 +1473,8 @@ def __init__(__self__, *,
:param str region: The region for the group of subnets.
:param Sequence[str] subnet_names: The names of the subnets in the region.
"""
- ElastigroupSubnet._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- region=region,
- subnet_names=subnet_names,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- region: Optional[str] = None,
- subnet_names: Optional[Sequence[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if region is None:
- raise TypeError("Missing 'region' argument")
- if subnet_names is None and 'subnetNames' in kwargs:
- subnet_names = kwargs['subnetNames']
- if subnet_names is None:
- raise TypeError("Missing 'subnet_names' argument")
-
- _setter("region", region)
- _setter("subnet_names", subnet_names)
+ pulumi.set(__self__, "region", region)
+ pulumi.set(__self__, "subnet_names", subnet_names)
@property
@pulumi.getter
diff --git a/sdk/python/pulumi_spotinst/gke/_inputs.py b/sdk/python/pulumi_spotinst/gke/_inputs.py
index fc81fb8e..69e79882 100644
--- a/sdk/python/pulumi_spotinst/gke/_inputs.py
+++ b/sdk/python/pulumi_spotinst/gke/_inputs.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
__all__ = [
@@ -70,38 +70,13 @@ def __init__(__self__, *,
location_type: Optional[pulumi.Input[str]] = None,
named_ports: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupBackendServiceNamedPortArgs']]]] = None,
scheme: Optional[pulumi.Input[str]] = None):
- ElastigroupBackendServiceArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- service_name=service_name,
- location_type=location_type,
- named_ports=named_ports,
- scheme=scheme,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- service_name: Optional[pulumi.Input[str]] = None,
- location_type: Optional[pulumi.Input[str]] = None,
- named_ports: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupBackendServiceNamedPortArgs']]]] = None,
- scheme: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if service_name is None and 'serviceName' in kwargs:
- service_name = kwargs['serviceName']
- if service_name is None:
- raise TypeError("Missing 'service_name' argument")
- if location_type is None and 'locationType' in kwargs:
- location_type = kwargs['locationType']
- if named_ports is None and 'namedPorts' in kwargs:
- named_ports = kwargs['namedPorts']
-
- _setter("service_name", service_name)
+ pulumi.set(__self__, "service_name", service_name)
if location_type is not None:
- _setter("location_type", location_type)
+ pulumi.set(__self__, "location_type", location_type)
if named_ports is not None:
- _setter("named_ports", named_ports)
+ pulumi.set(__self__, "named_ports", named_ports)
if scheme is not None:
- _setter("scheme", scheme)
+ pulumi.set(__self__, "scheme", scheme)
@property
@pulumi.getter(name="serviceName")
@@ -145,25 +120,8 @@ class ElastigroupBackendServiceNamedPortArgs:
def __init__(__self__, *,
name: pulumi.Input[str],
ports: pulumi.Input[Sequence[pulumi.Input[str]]]):
- ElastigroupBackendServiceNamedPortArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- ports=ports,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- ports: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
- if ports is None:
- raise TypeError("Missing 'ports' argument")
-
- _setter("name", name)
- _setter("ports", ports)
+ pulumi.set(__self__, "name", name)
+ pulumi.set(__self__, "ports", ports)
@property
@pulumi.getter
@@ -195,53 +153,22 @@ def __init__(__self__, *,
mode: Optional[pulumi.Input[str]] = None,
source: Optional[pulumi.Input[str]] = None,
type: Optional[pulumi.Input[str]] = None):
- ElastigroupDiskArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- auto_delete=auto_delete,
- boot=boot,
- device_name=device_name,
- initialize_params=initialize_params,
- interface=interface,
- mode=mode,
- source=source,
- type=type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- auto_delete: Optional[pulumi.Input[bool]] = None,
- boot: Optional[pulumi.Input[bool]] = None,
- device_name: Optional[pulumi.Input[str]] = None,
- initialize_params: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupDiskInitializeParamArgs']]]] = None,
- interface: Optional[pulumi.Input[str]] = None,
- mode: Optional[pulumi.Input[str]] = None,
- source: Optional[pulumi.Input[str]] = None,
- type: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if auto_delete is None and 'autoDelete' in kwargs:
- auto_delete = kwargs['autoDelete']
- if device_name is None and 'deviceName' in kwargs:
- device_name = kwargs['deviceName']
- if initialize_params is None and 'initializeParams' in kwargs:
- initialize_params = kwargs['initializeParams']
-
if auto_delete is not None:
- _setter("auto_delete", auto_delete)
+ pulumi.set(__self__, "auto_delete", auto_delete)
if boot is not None:
- _setter("boot", boot)
+ pulumi.set(__self__, "boot", boot)
if device_name is not None:
- _setter("device_name", device_name)
+ pulumi.set(__self__, "device_name", device_name)
if initialize_params is not None:
- _setter("initialize_params", initialize_params)
+ pulumi.set(__self__, "initialize_params", initialize_params)
if interface is not None:
- _setter("interface", interface)
+ pulumi.set(__self__, "interface", interface)
if mode is not None:
- _setter("mode", mode)
+ pulumi.set(__self__, "mode", mode)
if source is not None:
- _setter("source", source)
+ pulumi.set(__self__, "source", source)
if type is not None:
- _setter("type", type)
+ pulumi.set(__self__, "type", type)
@property
@pulumi.getter(name="autoDelete")
@@ -322,34 +249,11 @@ def __init__(__self__, *,
source_image: pulumi.Input[str],
disk_size_gb: Optional[pulumi.Input[str]] = None,
disk_type: Optional[pulumi.Input[str]] = None):
- ElastigroupDiskInitializeParamArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- source_image=source_image,
- disk_size_gb=disk_size_gb,
- disk_type=disk_type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- source_image: Optional[pulumi.Input[str]] = None,
- disk_size_gb: Optional[pulumi.Input[str]] = None,
- disk_type: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if source_image is None and 'sourceImage' in kwargs:
- source_image = kwargs['sourceImage']
- if source_image is None:
- raise TypeError("Missing 'source_image' argument")
- if disk_size_gb is None and 'diskSizeGb' in kwargs:
- disk_size_gb = kwargs['diskSizeGb']
- if disk_type is None and 'diskType' in kwargs:
- disk_type = kwargs['diskType']
-
- _setter("source_image", source_image)
+ pulumi.set(__self__, "source_image", source_image)
if disk_size_gb is not None:
- _setter("disk_size_gb", disk_size_gb)
+ pulumi.set(__self__, "disk_size_gb", disk_size_gb)
if disk_type is not None:
- _setter("disk_type", disk_type)
+ pulumi.set(__self__, "disk_type", disk_type)
@property
@pulumi.getter(name="sourceImage")
@@ -384,25 +288,8 @@ class ElastigroupGpuArgs:
def __init__(__self__, *,
count: pulumi.Input[int],
type: pulumi.Input[str]):
- ElastigroupGpuArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- count=count,
- type=type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- count: Optional[pulumi.Input[int]] = None,
- type: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if count is None:
- raise TypeError("Missing 'count' argument")
- if type is None:
- raise TypeError("Missing 'type' argument")
-
- _setter("count", count)
- _setter("type", type)
+ pulumi.set(__self__, "count", count)
+ pulumi.set(__self__, "type", type)
@property
@pulumi.getter
@@ -428,27 +315,8 @@ class ElastigroupInstanceTypesCustomArgs:
def __init__(__self__, *,
memory_gib: pulumi.Input[int],
vcpu: pulumi.Input[int]):
- ElastigroupInstanceTypesCustomArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- memory_gib=memory_gib,
- vcpu=vcpu,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- memory_gib: Optional[pulumi.Input[int]] = None,
- vcpu: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if memory_gib is None and 'memoryGib' in kwargs:
- memory_gib = kwargs['memoryGib']
- if memory_gib is None:
- raise TypeError("Missing 'memory_gib' argument")
- if vcpu is None:
- raise TypeError("Missing 'vcpu' argument")
-
- _setter("memory_gib", memory_gib)
- _setter("vcpu", vcpu)
+ pulumi.set(__self__, "memory_gib", memory_gib)
+ pulumi.set(__self__, "vcpu", vcpu)
@property
@pulumi.getter(name="memoryGib")
@@ -474,29 +342,8 @@ class ElastigroupIntegrationDockerSwarmArgs:
def __init__(__self__, *,
master_host: pulumi.Input[str],
master_port: pulumi.Input[int]):
- ElastigroupIntegrationDockerSwarmArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- master_host=master_host,
- master_port=master_port,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- master_host: Optional[pulumi.Input[str]] = None,
- master_port: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if master_host is None and 'masterHost' in kwargs:
- master_host = kwargs['masterHost']
- if master_host is None:
- raise TypeError("Missing 'master_host' argument")
- if master_port is None and 'masterPort' in kwargs:
- master_port = kwargs['masterPort']
- if master_port is None:
- raise TypeError("Missing 'master_port' argument")
-
- _setter("master_host", master_host)
- _setter("master_port", master_port)
+ pulumi.set(__self__, "master_host", master_host)
+ pulumi.set(__self__, "master_port", master_port)
@property
@pulumi.getter(name="masterHost")
@@ -538,67 +385,24 @@ def __init__(__self__, *,
:param pulumi.Input[str] cluster_id: The name of the GKE cluster you wish to import.
:param pulumi.Input[str] location: The location of your GKE cluster.
"""
- ElastigroupIntegrationGkeArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- auto_update=auto_update,
- autoscale_cooldown=autoscale_cooldown,
- autoscale_down=autoscale_down,
- autoscale_headroom=autoscale_headroom,
- autoscale_is_auto_config=autoscale_is_auto_config,
- autoscale_is_enabled=autoscale_is_enabled,
- autoscale_labels=autoscale_labels,
- cluster_id=cluster_id,
- location=location,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- auto_update: Optional[pulumi.Input[bool]] = None,
- autoscale_cooldown: Optional[pulumi.Input[int]] = None,
- autoscale_down: Optional[pulumi.Input['ElastigroupIntegrationGkeAutoscaleDownArgs']] = None,
- autoscale_headroom: Optional[pulumi.Input['ElastigroupIntegrationGkeAutoscaleHeadroomArgs']] = None,
- autoscale_is_auto_config: Optional[pulumi.Input[bool]] = None,
- autoscale_is_enabled: Optional[pulumi.Input[bool]] = None,
- autoscale_labels: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupIntegrationGkeAutoscaleLabelArgs']]]] = None,
- cluster_id: Optional[pulumi.Input[str]] = None,
- location: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if auto_update is None and 'autoUpdate' in kwargs:
- auto_update = kwargs['autoUpdate']
- if autoscale_cooldown is None and 'autoscaleCooldown' in kwargs:
- autoscale_cooldown = kwargs['autoscaleCooldown']
- if autoscale_down is None and 'autoscaleDown' in kwargs:
- autoscale_down = kwargs['autoscaleDown']
- if autoscale_headroom is None and 'autoscaleHeadroom' in kwargs:
- autoscale_headroom = kwargs['autoscaleHeadroom']
- if autoscale_is_auto_config is None and 'autoscaleIsAutoConfig' in kwargs:
- autoscale_is_auto_config = kwargs['autoscaleIsAutoConfig']
- if autoscale_is_enabled is None and 'autoscaleIsEnabled' in kwargs:
- autoscale_is_enabled = kwargs['autoscaleIsEnabled']
- if autoscale_labels is None and 'autoscaleLabels' in kwargs:
- autoscale_labels = kwargs['autoscaleLabels']
- if cluster_id is None and 'clusterId' in kwargs:
- cluster_id = kwargs['clusterId']
-
if auto_update is not None:
- _setter("auto_update", auto_update)
+ pulumi.set(__self__, "auto_update", auto_update)
if autoscale_cooldown is not None:
- _setter("autoscale_cooldown", autoscale_cooldown)
+ pulumi.set(__self__, "autoscale_cooldown", autoscale_cooldown)
if autoscale_down is not None:
- _setter("autoscale_down", autoscale_down)
+ pulumi.set(__self__, "autoscale_down", autoscale_down)
if autoscale_headroom is not None:
- _setter("autoscale_headroom", autoscale_headroom)
+ pulumi.set(__self__, "autoscale_headroom", autoscale_headroom)
if autoscale_is_auto_config is not None:
- _setter("autoscale_is_auto_config", autoscale_is_auto_config)
+ pulumi.set(__self__, "autoscale_is_auto_config", autoscale_is_auto_config)
if autoscale_is_enabled is not None:
- _setter("autoscale_is_enabled", autoscale_is_enabled)
+ pulumi.set(__self__, "autoscale_is_enabled", autoscale_is_enabled)
if autoscale_labels is not None:
- _setter("autoscale_labels", autoscale_labels)
+ pulumi.set(__self__, "autoscale_labels", autoscale_labels)
if cluster_id is not None:
- _setter("cluster_id", cluster_id)
+ pulumi.set(__self__, "cluster_id", cluster_id)
if location is not None:
- _setter("location", location)
+ pulumi.set(__self__, "location", location)
@property
@pulumi.getter(name="autoUpdate")
@@ -710,21 +514,8 @@ def __init__(__self__, *,
"""
:param pulumi.Input[int] evaluation_periods: Amount of cooldown evaluation periods for scale down.
"""
- ElastigroupIntegrationGkeAutoscaleDownArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- evaluation_periods=evaluation_periods,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- evaluation_periods: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
-
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
@property
@pulumi.getter(name="evaluationPeriods")
@@ -750,33 +541,12 @@ def __init__(__self__, *,
:param pulumi.Input[int] memory_per_unit: RAM units for compute.
:param pulumi.Input[int] num_of_units: Amount of units for compute.
"""
- ElastigroupIntegrationGkeAutoscaleHeadroomArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cpu_per_unit=cpu_per_unit,
- memory_per_unit=memory_per_unit,
- num_of_units=num_of_units,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cpu_per_unit: Optional[pulumi.Input[int]] = None,
- memory_per_unit: Optional[pulumi.Input[int]] = None,
- num_of_units: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cpu_per_unit is None and 'cpuPerUnit' in kwargs:
- cpu_per_unit = kwargs['cpuPerUnit']
- if memory_per_unit is None and 'memoryPerUnit' in kwargs:
- memory_per_unit = kwargs['memoryPerUnit']
- if num_of_units is None and 'numOfUnits' in kwargs:
- num_of_units = kwargs['numOfUnits']
-
if cpu_per_unit is not None:
- _setter("cpu_per_unit", cpu_per_unit)
+ pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
if memory_per_unit is not None:
- _setter("memory_per_unit", memory_per_unit)
+ pulumi.set(__self__, "memory_per_unit", memory_per_unit)
if num_of_units is not None:
- _setter("num_of_units", num_of_units)
+ pulumi.set(__self__, "num_of_units", num_of_units)
@property
@pulumi.getter(name="cpuPerUnit")
@@ -820,25 +590,8 @@ class ElastigroupIntegrationGkeAutoscaleLabelArgs:
def __init__(__self__, *,
key: pulumi.Input[str],
value: pulumi.Input[str]):
- ElastigroupIntegrationGkeAutoscaleLabelArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -864,25 +617,8 @@ class ElastigroupLabelArgs:
def __init__(__self__, *,
key: pulumi.Input[str],
value: pulumi.Input[str]):
- ElastigroupLabelArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -908,25 +644,8 @@ class ElastigroupMetadataArgs:
def __init__(__self__, *,
key: pulumi.Input[str],
value: pulumi.Input[str]):
- ElastigroupMetadataArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -953,32 +672,11 @@ def __init__(__self__, *,
network: pulumi.Input[str],
access_configs: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceAccessConfigArgs']]]] = None,
alias_ip_ranges: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceAliasIpRangeArgs']]]] = None):
- ElastigroupNetworkInterfaceArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- network=network,
- access_configs=access_configs,
- alias_ip_ranges=alias_ip_ranges,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- network: Optional[pulumi.Input[str]] = None,
- access_configs: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceAccessConfigArgs']]]] = None,
- alias_ip_ranges: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceAliasIpRangeArgs']]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if network is None:
- raise TypeError("Missing 'network' argument")
- if access_configs is None and 'accessConfigs' in kwargs:
- access_configs = kwargs['accessConfigs']
- if alias_ip_ranges is None and 'aliasIpRanges' in kwargs:
- alias_ip_ranges = kwargs['aliasIpRanges']
-
- _setter("network", network)
+ pulumi.set(__self__, "network", network)
if access_configs is not None:
- _setter("access_configs", access_configs)
+ pulumi.set(__self__, "access_configs", access_configs)
if alias_ip_ranges is not None:
- _setter("alias_ip_ranges", alias_ip_ranges)
+ pulumi.set(__self__, "alias_ip_ranges", alias_ip_ranges)
@property
@pulumi.getter
@@ -1013,23 +711,10 @@ class ElastigroupNetworkInterfaceAccessConfigArgs:
def __init__(__self__, *,
name: Optional[pulumi.Input[str]] = None,
type: Optional[pulumi.Input[str]] = None):
- ElastigroupNetworkInterfaceAccessConfigArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- type=type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- type: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if type is not None:
- _setter("type", type)
+ pulumi.set(__self__, "type", type)
@property
@pulumi.getter
@@ -1055,29 +740,8 @@ class ElastigroupNetworkInterfaceAliasIpRangeArgs:
def __init__(__self__, *,
ip_cidr_range: pulumi.Input[str],
subnetwork_range_name: pulumi.Input[str]):
- ElastigroupNetworkInterfaceAliasIpRangeArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- ip_cidr_range=ip_cidr_range,
- subnetwork_range_name=subnetwork_range_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- ip_cidr_range: Optional[pulumi.Input[str]] = None,
- subnetwork_range_name: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if ip_cidr_range is None and 'ipCidrRange' in kwargs:
- ip_cidr_range = kwargs['ipCidrRange']
- if ip_cidr_range is None:
- raise TypeError("Missing 'ip_cidr_range' argument")
- if subnetwork_range_name is None and 'subnetworkRangeName' in kwargs:
- subnetwork_range_name = kwargs['subnetworkRangeName']
- if subnetwork_range_name is None:
- raise TypeError("Missing 'subnetwork_range_name' argument")
-
- _setter("ip_cidr_range", ip_cidr_range)
- _setter("subnetwork_range_name", subnetwork_range_name)
+ pulumi.set(__self__, "ip_cidr_range", ip_cidr_range)
+ pulumi.set(__self__, "subnetwork_range_name", subnetwork_range_name)
@property
@pulumi.getter(name="ipCidrRange")
@@ -1118,84 +782,29 @@ def __init__(__self__, *,
"""
:param pulumi.Input[int] evaluation_periods: Amount of cooldown evaluation periods for scale down.
"""
- ElastigroupScalingDownPolicyArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- metric_name=metric_name,
- namespace=namespace,
- policy_name=policy_name,
- threshold=threshold,
- unit=unit,
- action_type=action_type,
- adjustment=adjustment,
- cooldown=cooldown,
- dimensions=dimensions,
- evaluation_periods=evaluation_periods,
- operator=operator,
- period=period,
- source=source,
- statistic=statistic,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- metric_name: Optional[pulumi.Input[str]] = None,
- namespace: Optional[pulumi.Input[str]] = None,
- policy_name: Optional[pulumi.Input[str]] = None,
- threshold: Optional[pulumi.Input[float]] = None,
- unit: Optional[pulumi.Input[str]] = None,
- action_type: Optional[pulumi.Input[str]] = None,
- adjustment: Optional[pulumi.Input[int]] = None,
- cooldown: Optional[pulumi.Input[int]] = None,
- dimensions: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyDimensionArgs']]]] = None,
- evaluation_periods: Optional[pulumi.Input[int]] = None,
- operator: Optional[pulumi.Input[str]] = None,
- period: Optional[pulumi.Input[int]] = None,
- source: Optional[pulumi.Input[str]] = None,
- statistic: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if metric_name is None and 'metricName' in kwargs:
- metric_name = kwargs['metricName']
- if metric_name is None:
- raise TypeError("Missing 'metric_name' argument")
- if namespace is None:
- raise TypeError("Missing 'namespace' argument")
- if policy_name is None and 'policyName' in kwargs:
- policy_name = kwargs['policyName']
- if policy_name is None:
- raise TypeError("Missing 'policy_name' argument")
- if threshold is None:
- raise TypeError("Missing 'threshold' argument")
- if unit is None:
- raise TypeError("Missing 'unit' argument")
- if action_type is None and 'actionType' in kwargs:
- action_type = kwargs['actionType']
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
-
- _setter("metric_name", metric_name)
- _setter("namespace", namespace)
- _setter("policy_name", policy_name)
- _setter("threshold", threshold)
- _setter("unit", unit)
+ pulumi.set(__self__, "metric_name", metric_name)
+ pulumi.set(__self__, "namespace", namespace)
+ pulumi.set(__self__, "policy_name", policy_name)
+ pulumi.set(__self__, "threshold", threshold)
+ pulumi.set(__self__, "unit", unit)
if action_type is not None:
- _setter("action_type", action_type)
+ pulumi.set(__self__, "action_type", action_type)
if adjustment is not None:
- _setter("adjustment", adjustment)
+ pulumi.set(__self__, "adjustment", adjustment)
if cooldown is not None:
- _setter("cooldown", cooldown)
+ pulumi.set(__self__, "cooldown", cooldown)
if dimensions is not None:
- _setter("dimensions", dimensions)
+ pulumi.set(__self__, "dimensions", dimensions)
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
if operator is not None:
- _setter("operator", operator)
+ pulumi.set(__self__, "operator", operator)
if period is not None:
- _setter("period", period)
+ pulumi.set(__self__, "period", period)
if source is not None:
- _setter("source", source)
+ pulumi.set(__self__, "source", source)
if statistic is not None:
- _setter("statistic", statistic)
+ pulumi.set(__self__, "statistic", statistic)
@property
@pulumi.getter(name="metricName")
@@ -1332,24 +941,9 @@ class ElastigroupScalingDownPolicyDimensionArgs:
def __init__(__self__, *,
name: pulumi.Input[str],
value: Optional[pulumi.Input[str]] = None):
- ElastigroupScalingDownPolicyDimensionArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
-
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if value is not None:
- _setter("value", value)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -1390,84 +984,29 @@ def __init__(__self__, *,
"""
:param pulumi.Input[int] evaluation_periods: Amount of cooldown evaluation periods for scale down.
"""
- ElastigroupScalingUpPolicyArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- metric_name=metric_name,
- namespace=namespace,
- policy_name=policy_name,
- threshold=threshold,
- unit=unit,
- action_type=action_type,
- adjustment=adjustment,
- cooldown=cooldown,
- dimensions=dimensions,
- evaluation_periods=evaluation_periods,
- operator=operator,
- period=period,
- source=source,
- statistic=statistic,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- metric_name: Optional[pulumi.Input[str]] = None,
- namespace: Optional[pulumi.Input[str]] = None,
- policy_name: Optional[pulumi.Input[str]] = None,
- threshold: Optional[pulumi.Input[float]] = None,
- unit: Optional[pulumi.Input[str]] = None,
- action_type: Optional[pulumi.Input[str]] = None,
- adjustment: Optional[pulumi.Input[int]] = None,
- cooldown: Optional[pulumi.Input[int]] = None,
- dimensions: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyDimensionArgs']]]] = None,
- evaluation_periods: Optional[pulumi.Input[int]] = None,
- operator: Optional[pulumi.Input[str]] = None,
- period: Optional[pulumi.Input[int]] = None,
- source: Optional[pulumi.Input[str]] = None,
- statistic: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if metric_name is None and 'metricName' in kwargs:
- metric_name = kwargs['metricName']
- if metric_name is None:
- raise TypeError("Missing 'metric_name' argument")
- if namespace is None:
- raise TypeError("Missing 'namespace' argument")
- if policy_name is None and 'policyName' in kwargs:
- policy_name = kwargs['policyName']
- if policy_name is None:
- raise TypeError("Missing 'policy_name' argument")
- if threshold is None:
- raise TypeError("Missing 'threshold' argument")
- if unit is None:
- raise TypeError("Missing 'unit' argument")
- if action_type is None and 'actionType' in kwargs:
- action_type = kwargs['actionType']
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
-
- _setter("metric_name", metric_name)
- _setter("namespace", namespace)
- _setter("policy_name", policy_name)
- _setter("threshold", threshold)
- _setter("unit", unit)
+ pulumi.set(__self__, "metric_name", metric_name)
+ pulumi.set(__self__, "namespace", namespace)
+ pulumi.set(__self__, "policy_name", policy_name)
+ pulumi.set(__self__, "threshold", threshold)
+ pulumi.set(__self__, "unit", unit)
if action_type is not None:
- _setter("action_type", action_type)
+ pulumi.set(__self__, "action_type", action_type)
if adjustment is not None:
- _setter("adjustment", adjustment)
+ pulumi.set(__self__, "adjustment", adjustment)
if cooldown is not None:
- _setter("cooldown", cooldown)
+ pulumi.set(__self__, "cooldown", cooldown)
if dimensions is not None:
- _setter("dimensions", dimensions)
+ pulumi.set(__self__, "dimensions", dimensions)
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
if operator is not None:
- _setter("operator", operator)
+ pulumi.set(__self__, "operator", operator)
if period is not None:
- _setter("period", period)
+ pulumi.set(__self__, "period", period)
if source is not None:
- _setter("source", source)
+ pulumi.set(__self__, "source", source)
if statistic is not None:
- _setter("statistic", statistic)
+ pulumi.set(__self__, "statistic", statistic)
@property
@pulumi.getter(name="metricName")
@@ -1604,24 +1143,9 @@ class ElastigroupScalingUpPolicyDimensionArgs:
def __init__(__self__, *,
name: pulumi.Input[str],
value: Optional[pulumi.Input[str]] = None):
- ElastigroupScalingUpPolicyDimensionArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
-
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if value is not None:
- _setter("value", value)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -1663,57 +1187,22 @@ def __init__(__self__, *,
:param pulumi.Input[bool] is_enabled: Enable the Ocean Kubernetes Autoscaler.
:param pulumi.Input['OceanImportAutoscalerResourceLimitsArgs'] resource_limits: Optionally set upper and lower bounds on the resource usage of the cluster.
"""
- OceanImportAutoscalerArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- auto_headroom_percentage=auto_headroom_percentage,
- cooldown=cooldown,
- down=down,
- enable_automatic_and_manual_headroom=enable_automatic_and_manual_headroom,
- headroom=headroom,
- is_auto_config=is_auto_config,
- is_enabled=is_enabled,
- resource_limits=resource_limits,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- auto_headroom_percentage: Optional[pulumi.Input[int]] = None,
- cooldown: Optional[pulumi.Input[int]] = None,
- down: Optional[pulumi.Input['OceanImportAutoscalerDownArgs']] = None,
- enable_automatic_and_manual_headroom: Optional[pulumi.Input[bool]] = None,
- headroom: Optional[pulumi.Input['OceanImportAutoscalerHeadroomArgs']] = None,
- is_auto_config: Optional[pulumi.Input[bool]] = None,
- is_enabled: Optional[pulumi.Input[bool]] = None,
- resource_limits: Optional[pulumi.Input['OceanImportAutoscalerResourceLimitsArgs']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if auto_headroom_percentage is None and 'autoHeadroomPercentage' in kwargs:
- auto_headroom_percentage = kwargs['autoHeadroomPercentage']
- if enable_automatic_and_manual_headroom is None and 'enableAutomaticAndManualHeadroom' in kwargs:
- enable_automatic_and_manual_headroom = kwargs['enableAutomaticAndManualHeadroom']
- if is_auto_config is None and 'isAutoConfig' in kwargs:
- is_auto_config = kwargs['isAutoConfig']
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
- if resource_limits is None and 'resourceLimits' in kwargs:
- resource_limits = kwargs['resourceLimits']
-
if auto_headroom_percentage is not None:
- _setter("auto_headroom_percentage", auto_headroom_percentage)
+ pulumi.set(__self__, "auto_headroom_percentage", auto_headroom_percentage)
if cooldown is not None:
- _setter("cooldown", cooldown)
+ pulumi.set(__self__, "cooldown", cooldown)
if down is not None:
- _setter("down", down)
+ pulumi.set(__self__, "down", down)
if enable_automatic_and_manual_headroom is not None:
- _setter("enable_automatic_and_manual_headroom", enable_automatic_and_manual_headroom)
+ pulumi.set(__self__, "enable_automatic_and_manual_headroom", enable_automatic_and_manual_headroom)
if headroom is not None:
- _setter("headroom", headroom)
+ pulumi.set(__self__, "headroom", headroom)
if is_auto_config is not None:
- _setter("is_auto_config", is_auto_config)
+ pulumi.set(__self__, "is_auto_config", is_auto_config)
if is_enabled is not None:
- _setter("is_enabled", is_enabled)
+ pulumi.set(__self__, "is_enabled", is_enabled)
if resource_limits is not None:
- _setter("resource_limits", resource_limits)
+ pulumi.set(__self__, "resource_limits", resource_limits)
@property
@pulumi.getter(name="autoHeadroomPercentage")
@@ -1821,27 +1310,10 @@ def __init__(__self__, *,
:param pulumi.Input[int] evaluation_periods: The number of evaluation periods that should accumulate before a scale down action takes place.
:param pulumi.Input[float] max_scale_down_percentage: Would represent the maximum % to scale-down. Number between 1-100.
"""
- OceanImportAutoscalerDownArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- evaluation_periods=evaluation_periods,
- max_scale_down_percentage=max_scale_down_percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- evaluation_periods: Optional[pulumi.Input[int]] = None,
- max_scale_down_percentage: Optional[pulumi.Input[float]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
- if max_scale_down_percentage is None and 'maxScaleDownPercentage' in kwargs:
- max_scale_down_percentage = kwargs['maxScaleDownPercentage']
-
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
if max_scale_down_percentage is not None:
- _setter("max_scale_down_percentage", max_scale_down_percentage)
+ pulumi.set(__self__, "max_scale_down_percentage", max_scale_down_percentage)
@property
@pulumi.getter(name="evaluationPeriods")
@@ -1881,39 +1353,14 @@ def __init__(__self__, *,
:param pulumi.Input[int] memory_per_unit: Optionally configure the amount of memory (MiB) to allocate the headroom.
:param pulumi.Input[int] num_of_units: The number of units to retain as headroom, where each unit has the defined headroom CPU and memory.
"""
- OceanImportAutoscalerHeadroomArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cpu_per_unit=cpu_per_unit,
- gpu_per_unit=gpu_per_unit,
- memory_per_unit=memory_per_unit,
- num_of_units=num_of_units,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cpu_per_unit: Optional[pulumi.Input[int]] = None,
- gpu_per_unit: Optional[pulumi.Input[int]] = None,
- memory_per_unit: Optional[pulumi.Input[int]] = None,
- num_of_units: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cpu_per_unit is None and 'cpuPerUnit' in kwargs:
- cpu_per_unit = kwargs['cpuPerUnit']
- if gpu_per_unit is None and 'gpuPerUnit' in kwargs:
- gpu_per_unit = kwargs['gpuPerUnit']
- if memory_per_unit is None and 'memoryPerUnit' in kwargs:
- memory_per_unit = kwargs['memoryPerUnit']
- if num_of_units is None and 'numOfUnits' in kwargs:
- num_of_units = kwargs['numOfUnits']
-
if cpu_per_unit is not None:
- _setter("cpu_per_unit", cpu_per_unit)
+ pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
if gpu_per_unit is not None:
- _setter("gpu_per_unit", gpu_per_unit)
+ pulumi.set(__self__, "gpu_per_unit", gpu_per_unit)
if memory_per_unit is not None:
- _setter("memory_per_unit", memory_per_unit)
+ pulumi.set(__self__, "memory_per_unit", memory_per_unit)
if num_of_units is not None:
- _setter("num_of_units", num_of_units)
+ pulumi.set(__self__, "num_of_units", num_of_units)
@property
@pulumi.getter(name="cpuPerUnit")
@@ -1979,27 +1426,10 @@ def __init__(__self__, *,
:param pulumi.Input[int] max_vcpu: The maximum cpu in vCpu units that can be allocated to the cluster.
"""
- OceanImportAutoscalerResourceLimitsArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- max_memory_gib=max_memory_gib,
- max_vcpu=max_vcpu,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- max_memory_gib: Optional[pulumi.Input[int]] = None,
- max_vcpu: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if max_memory_gib is None and 'maxMemoryGib' in kwargs:
- max_memory_gib = kwargs['maxMemoryGib']
- if max_vcpu is None and 'maxVcpu' in kwargs:
- max_vcpu = kwargs['maxVcpu']
-
if max_memory_gib is not None:
- _setter("max_memory_gib", max_memory_gib)
+ pulumi.set(__self__, "max_memory_gib", max_memory_gib)
if max_vcpu is not None:
- _setter("max_vcpu", max_vcpu)
+ pulumi.set(__self__, "max_vcpu", max_vcpu)
@property
@pulumi.getter(name="maxMemoryGib")
@@ -2044,38 +1474,13 @@ def __init__(__self__, *,
:param pulumi.Input[str] location_type: Sets which location the backend services will be active. Valid values: `regional`, `global`.
:param pulumi.Input[str] scheme: Use when `location_type` is `regional`. Set the traffic for the backend service to either between the instances in the vpc or to traffic from the internet. Valid values: `INTERNAL`, `EXTERNAL`.
"""
- OceanImportBackendServiceArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- service_name=service_name,
- location_type=location_type,
- named_ports=named_ports,
- scheme=scheme,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- service_name: Optional[pulumi.Input[str]] = None,
- location_type: Optional[pulumi.Input[str]] = None,
- named_ports: Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportBackendServiceNamedPortArgs']]]] = None,
- scheme: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if service_name is None and 'serviceName' in kwargs:
- service_name = kwargs['serviceName']
- if service_name is None:
- raise TypeError("Missing 'service_name' argument")
- if location_type is None and 'locationType' in kwargs:
- location_type = kwargs['locationType']
- if named_ports is None and 'namedPorts' in kwargs:
- named_ports = kwargs['namedPorts']
-
- _setter("service_name", service_name)
+ pulumi.set(__self__, "service_name", service_name)
if location_type is not None:
- _setter("location_type", location_type)
+ pulumi.set(__self__, "location_type", location_type)
if named_ports is not None:
- _setter("named_ports", named_ports)
+ pulumi.set(__self__, "named_ports", named_ports)
if scheme is not None:
- _setter("scheme", scheme)
+ pulumi.set(__self__, "scheme", scheme)
@property
@pulumi.getter(name="serviceName")
@@ -2131,25 +1536,8 @@ def __init__(__self__, *,
"""
:param pulumi.Input[Sequence[pulumi.Input[str]]] ports: A list of ports.
"""
- OceanImportBackendServiceNamedPortArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- ports=ports,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- ports: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
- if ports is None:
- raise TypeError("Missing 'ports' argument")
-
- _setter("name", name)
- _setter("ports", ports)
+ pulumi.set(__self__, "name", name)
+ pulumi.set(__self__, "ports", ports)
@property
@pulumi.getter
@@ -2182,25 +1570,10 @@ def __init__(__self__, *,
:param pulumi.Input['OceanImportScheduledTaskShutdownHoursArgs'] shutdown_hours: Set shutdown hours for cluster object.
:param pulumi.Input[Sequence[pulumi.Input['OceanImportScheduledTaskTaskArgs']]] tasks: The scheduling tasks for the cluster.
"""
- OceanImportScheduledTaskArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- shutdown_hours=shutdown_hours,
- tasks=tasks,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- shutdown_hours: Optional[pulumi.Input['OceanImportScheduledTaskShutdownHoursArgs']] = None,
- tasks: Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportScheduledTaskTaskArgs']]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if shutdown_hours is None and 'shutdownHours' in kwargs:
- shutdown_hours = kwargs['shutdownHours']
-
if shutdown_hours is not None:
- _setter("shutdown_hours", shutdown_hours)
+ pulumi.set(__self__, "shutdown_hours", shutdown_hours)
if tasks is not None:
- _setter("tasks", tasks)
+ pulumi.set(__self__, "tasks", tasks)
@property
@pulumi.getter(name="shutdownHours")
@@ -2237,28 +1610,9 @@ def __init__(__self__, *,
Example: Fri:15:30-Wed:14:30
:param pulumi.Input[bool] is_enabled: Enable the Ocean Kubernetes Autoscaler.
"""
- OceanImportScheduledTaskShutdownHoursArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- time_windows=time_windows,
- is_enabled=is_enabled,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- time_windows: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- is_enabled: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if time_windows is None and 'timeWindows' in kwargs:
- time_windows = kwargs['timeWindows']
- if time_windows is None:
- raise TypeError("Missing 'time_windows' argument")
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
-
- _setter("time_windows", time_windows)
+ pulumi.set(__self__, "time_windows", time_windows)
if is_enabled is not None:
- _setter("is_enabled", is_enabled)
+ pulumi.set(__self__, "is_enabled", is_enabled)
@property
@pulumi.getter(name="timeWindows")
@@ -2299,42 +1653,11 @@ def __init__(__self__, *,
:param pulumi.Input[bool] is_enabled: Enable the Ocean Kubernetes Autoscaler.
:param pulumi.Input[str] task_type: Valid values: "clusterRoll". Required for cluster.scheduling.tasks object.
"""
- OceanImportScheduledTaskTaskArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cron_expression=cron_expression,
- is_enabled=is_enabled,
- task_type=task_type,
- task_parameters=task_parameters,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cron_expression: Optional[pulumi.Input[str]] = None,
- is_enabled: Optional[pulumi.Input[bool]] = None,
- task_type: Optional[pulumi.Input[str]] = None,
- task_parameters: Optional[pulumi.Input['OceanImportScheduledTaskTaskTaskParametersArgs']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cron_expression is None and 'cronExpression' in kwargs:
- cron_expression = kwargs['cronExpression']
- if cron_expression is None:
- raise TypeError("Missing 'cron_expression' argument")
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
- if is_enabled is None:
- raise TypeError("Missing 'is_enabled' argument")
- if task_type is None and 'taskType' in kwargs:
- task_type = kwargs['taskType']
- if task_type is None:
- raise TypeError("Missing 'task_type' argument")
- if task_parameters is None and 'taskParameters' in kwargs:
- task_parameters = kwargs['taskParameters']
-
- _setter("cron_expression", cron_expression)
- _setter("is_enabled", is_enabled)
- _setter("task_type", task_type)
+ pulumi.set(__self__, "cron_expression", cron_expression)
+ pulumi.set(__self__, "is_enabled", is_enabled)
+ pulumi.set(__self__, "task_type", task_type)
if task_parameters is not None:
- _setter("task_parameters", task_parameters)
+ pulumi.set(__self__, "task_parameters", task_parameters)
@property
@pulumi.getter(name="cronExpression")
@@ -2387,21 +1710,8 @@ def task_parameters(self, value: Optional[pulumi.Input['OceanImportScheduledTask
class OceanImportScheduledTaskTaskTaskParametersArgs:
def __init__(__self__, *,
cluster_roll: Optional[pulumi.Input['OceanImportScheduledTaskTaskTaskParametersClusterRollArgs']] = None):
- OceanImportScheduledTaskTaskTaskParametersArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cluster_roll=cluster_roll,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cluster_roll: Optional[pulumi.Input['OceanImportScheduledTaskTaskTaskParametersClusterRollArgs']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cluster_roll is None and 'clusterRoll' in kwargs:
- cluster_roll = kwargs['clusterRoll']
-
if cluster_roll is not None:
- _setter("cluster_roll", cluster_roll)
+ pulumi.set(__self__, "cluster_roll", cluster_roll)
@property
@pulumi.getter(name="clusterRoll")
@@ -2428,37 +1738,14 @@ def __init__(__self__, *,
import pulumi
```
"""
- OceanImportScheduledTaskTaskTaskParametersClusterRollArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- batch_min_healthy_percentage=batch_min_healthy_percentage,
- batch_size_percentage=batch_size_percentage,
- comment=comment,
- respect_pdb=respect_pdb,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- batch_min_healthy_percentage: Optional[pulumi.Input[int]] = None,
- batch_size_percentage: Optional[pulumi.Input[int]] = None,
- comment: Optional[pulumi.Input[str]] = None,
- respect_pdb: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if batch_min_healthy_percentage is None and 'batchMinHealthyPercentage' in kwargs:
- batch_min_healthy_percentage = kwargs['batchMinHealthyPercentage']
- if batch_size_percentage is None and 'batchSizePercentage' in kwargs:
- batch_size_percentage = kwargs['batchSizePercentage']
- if respect_pdb is None and 'respectPdb' in kwargs:
- respect_pdb = kwargs['respectPdb']
-
if batch_min_healthy_percentage is not None:
- _setter("batch_min_healthy_percentage", batch_min_healthy_percentage)
+ pulumi.set(__self__, "batch_min_healthy_percentage", batch_min_healthy_percentage)
if batch_size_percentage is not None:
- _setter("batch_size_percentage", batch_size_percentage)
+ pulumi.set(__self__, "batch_size_percentage", batch_size_percentage)
if comment is not None:
- _setter("comment", comment)
+ pulumi.set(__self__, "comment", comment)
if respect_pdb is not None:
- _setter("respect_pdb", respect_pdb)
+ pulumi.set(__self__, "respect_pdb", respect_pdb)
@property
@pulumi.getter(name="batchMinHealthyPercentage")
@@ -2514,27 +1801,10 @@ def __init__(__self__, *,
:param pulumi.Input[bool] enable_integrity_monitoring: Boolean. Enable the integrity monitoring parameter on the GCP instances.
:param pulumi.Input[bool] enable_secure_boot: Boolean. Enable the secure boot parameter on the GCP instances.
"""
- OceanImportShieldedInstanceConfigArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- enable_integrity_monitoring=enable_integrity_monitoring,
- enable_secure_boot=enable_secure_boot,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- enable_integrity_monitoring: Optional[pulumi.Input[bool]] = None,
- enable_secure_boot: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if enable_integrity_monitoring is None and 'enableIntegrityMonitoring' in kwargs:
- enable_integrity_monitoring = kwargs['enableIntegrityMonitoring']
- if enable_secure_boot is None and 'enableSecureBoot' in kwargs:
- enable_secure_boot = kwargs['enableSecureBoot']
-
if enable_integrity_monitoring is not None:
- _setter("enable_integrity_monitoring", enable_integrity_monitoring)
+ pulumi.set(__self__, "enable_integrity_monitoring", enable_integrity_monitoring)
if enable_secure_boot is not None:
- _setter("enable_secure_boot", enable_secure_boot)
+ pulumi.set(__self__, "enable_secure_boot", enable_secure_boot)
@property
@pulumi.getter(name="enableIntegrityMonitoring")
@@ -2570,33 +1840,12 @@ def __init__(__self__, *,
"""
:param pulumi.Input[int] draining_timeout: The draining timeout (in seconds) before terminating the instance.
"""
- OceanImportStrategyArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- draining_timeout=draining_timeout,
- preemptible_percentage=preemptible_percentage,
- provisioning_model=provisioning_model,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- draining_timeout: Optional[pulumi.Input[int]] = None,
- preemptible_percentage: Optional[pulumi.Input[int]] = None,
- provisioning_model: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if draining_timeout is None and 'drainingTimeout' in kwargs:
- draining_timeout = kwargs['drainingTimeout']
- if preemptible_percentage is None and 'preemptiblePercentage' in kwargs:
- preemptible_percentage = kwargs['preemptiblePercentage']
- if provisioning_model is None and 'provisioningModel' in kwargs:
- provisioning_model = kwargs['provisioningModel']
-
if draining_timeout is not None:
- _setter("draining_timeout", draining_timeout)
+ pulumi.set(__self__, "draining_timeout", draining_timeout)
if preemptible_percentage is not None:
- _setter("preemptible_percentage", preemptible_percentage)
+ pulumi.set(__self__, "preemptible_percentage", preemptible_percentage)
if provisioning_model is not None:
- _setter("provisioning_model", provisioning_model)
+ pulumi.set(__self__, "provisioning_model", provisioning_model)
@property
@pulumi.getter(name="drainingTimeout")
@@ -2635,34 +1884,11 @@ def __init__(__self__, *,
should_roll: pulumi.Input[bool],
conditioned_roll: Optional[pulumi.Input[bool]] = None,
roll_config: Optional[pulumi.Input['OceanImportUpdatePolicyRollConfigArgs']] = None):
- OceanImportUpdatePolicyArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- should_roll=should_roll,
- conditioned_roll=conditioned_roll,
- roll_config=roll_config,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- should_roll: Optional[pulumi.Input[bool]] = None,
- conditioned_roll: Optional[pulumi.Input[bool]] = None,
- roll_config: Optional[pulumi.Input['OceanImportUpdatePolicyRollConfigArgs']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if should_roll is None and 'shouldRoll' in kwargs:
- should_roll = kwargs['shouldRoll']
- if should_roll is None:
- raise TypeError("Missing 'should_roll' argument")
- if conditioned_roll is None and 'conditionedRoll' in kwargs:
- conditioned_roll = kwargs['conditionedRoll']
- if roll_config is None and 'rollConfig' in kwargs:
- roll_config = kwargs['rollConfig']
-
- _setter("should_roll", should_roll)
+ pulumi.set(__self__, "should_roll", should_roll)
if conditioned_roll is not None:
- _setter("conditioned_roll", conditioned_roll)
+ pulumi.set(__self__, "conditioned_roll", conditioned_roll)
if roll_config is not None:
- _setter("roll_config", roll_config)
+ pulumi.set(__self__, "roll_config", roll_config)
@property
@pulumi.getter(name="shouldRoll")
@@ -2707,40 +1933,13 @@ def __init__(__self__, *,
import pulumi
```
"""
- OceanImportUpdatePolicyRollConfigArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- batch_size_percentage=batch_size_percentage,
- batch_min_healthy_percentage=batch_min_healthy_percentage,
- launch_spec_ids=launch_spec_ids,
- respect_pdb=respect_pdb,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- batch_size_percentage: Optional[pulumi.Input[int]] = None,
- batch_min_healthy_percentage: Optional[pulumi.Input[int]] = None,
- launch_spec_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- respect_pdb: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if batch_size_percentage is None and 'batchSizePercentage' in kwargs:
- batch_size_percentage = kwargs['batchSizePercentage']
- if batch_size_percentage is None:
- raise TypeError("Missing 'batch_size_percentage' argument")
- if batch_min_healthy_percentage is None and 'batchMinHealthyPercentage' in kwargs:
- batch_min_healthy_percentage = kwargs['batchMinHealthyPercentage']
- if launch_spec_ids is None and 'launchSpecIds' in kwargs:
- launch_spec_ids = kwargs['launchSpecIds']
- if respect_pdb is None and 'respectPdb' in kwargs:
- respect_pdb = kwargs['respectPdb']
-
- _setter("batch_size_percentage", batch_size_percentage)
+ pulumi.set(__self__, "batch_size_percentage", batch_size_percentage)
if batch_min_healthy_percentage is not None:
- _setter("batch_min_healthy_percentage", batch_min_healthy_percentage)
+ pulumi.set(__self__, "batch_min_healthy_percentage", batch_min_healthy_percentage)
if launch_spec_ids is not None:
- _setter("launch_spec_ids", launch_spec_ids)
+ pulumi.set(__self__, "launch_spec_ids", launch_spec_ids)
if respect_pdb is not None:
- _setter("respect_pdb", respect_pdb)
+ pulumi.set(__self__, "respect_pdb", respect_pdb)
@property
@pulumi.getter(name="batchSizePercentage")
@@ -2800,40 +1999,13 @@ def __init__(__self__, *,
:param pulumi.Input[int] gpu_per_unit: Optionally configure the number of GPUS to allocate for each headroom unit.
:param pulumi.Input[int] memory_per_unit: Optionally configure the amount of memory (MiB) to allocate for each headroom unit.
"""
- OceanLaunchSpecAutoscaleHeadroomArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- num_of_units=num_of_units,
- cpu_per_unit=cpu_per_unit,
- gpu_per_unit=gpu_per_unit,
- memory_per_unit=memory_per_unit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- num_of_units: Optional[pulumi.Input[int]] = None,
- cpu_per_unit: Optional[pulumi.Input[int]] = None,
- gpu_per_unit: Optional[pulumi.Input[int]] = None,
- memory_per_unit: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if num_of_units is None and 'numOfUnits' in kwargs:
- num_of_units = kwargs['numOfUnits']
- if num_of_units is None:
- raise TypeError("Missing 'num_of_units' argument")
- if cpu_per_unit is None and 'cpuPerUnit' in kwargs:
- cpu_per_unit = kwargs['cpuPerUnit']
- if gpu_per_unit is None and 'gpuPerUnit' in kwargs:
- gpu_per_unit = kwargs['gpuPerUnit']
- if memory_per_unit is None and 'memoryPerUnit' in kwargs:
- memory_per_unit = kwargs['memoryPerUnit']
-
- _setter("num_of_units", num_of_units)
+ pulumi.set(__self__, "num_of_units", num_of_units)
if cpu_per_unit is not None:
- _setter("cpu_per_unit", cpu_per_unit)
+ pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
if gpu_per_unit is not None:
- _setter("gpu_per_unit", gpu_per_unit)
+ pulumi.set(__self__, "gpu_per_unit", gpu_per_unit)
if memory_per_unit is not None:
- _setter("memory_per_unit", memory_per_unit)
+ pulumi.set(__self__, "memory_per_unit", memory_per_unit)
@property
@pulumi.getter(name="numOfUnits")
@@ -2891,21 +2063,8 @@ def __init__(__self__, *,
"""
:param pulumi.Input[int] auto_headroom_percentage: Number between 0-200 to control the headroom % of the specific Virtual Node Group. Effective when cluster.autoScaler.headroom.automatic.`is_enabled` = true is set on the Ocean cluster.
"""
- OceanLaunchSpecAutoscaleHeadroomsAutomaticArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- auto_headroom_percentage=auto_headroom_percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- auto_headroom_percentage: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if auto_headroom_percentage is None and 'autoHeadroomPercentage' in kwargs:
- auto_headroom_percentage = kwargs['autoHeadroomPercentage']
-
if auto_headroom_percentage is not None:
- _setter("auto_headroom_percentage", auto_headroom_percentage)
+ pulumi.set(__self__, "auto_headroom_percentage", auto_headroom_percentage)
@property
@pulumi.getter(name="autoHeadroomPercentage")
@@ -2929,23 +2088,10 @@ def __init__(__self__, *,
:param pulumi.Input[str] key: The label key.
:param pulumi.Input[str] value: The label value.
"""
- OceanLaunchSpecLabelArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if key is not None:
- _setter("key", key)
+ pulumi.set(__self__, "key", key)
if value is not None:
- _setter("value", value)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -2981,23 +2127,10 @@ def __init__(__self__, *,
:param pulumi.Input[str] key: The label key.
:param pulumi.Input[str] value: The label value.
"""
- OceanLaunchSpecMetadataArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if key is not None:
- _setter("key", key)
+ pulumi.set(__self__, "key", key)
if value is not None:
- _setter("value", value)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -3037,38 +2170,13 @@ def __init__(__self__, *,
:param pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecNetworkInterfaceAliasIpRangeArgs']]] alias_ip_ranges: use the imported node pool’s associated aliasIpRange to assign secondary IP addresses to the nodes. Cannot be changed after VNG creation.
:param pulumi.Input[str] project_id: Use a network resource from a different project. Set the project identifier to use its network resource. This parameter is relevant only if the network resource is in a different project.
"""
- OceanLaunchSpecNetworkInterfaceArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- network=network,
- access_configs=access_configs,
- alias_ip_ranges=alias_ip_ranges,
- project_id=project_id,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- network: Optional[pulumi.Input[str]] = None,
- access_configs: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecNetworkInterfaceAccessConfigArgs']]]] = None,
- alias_ip_ranges: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecNetworkInterfaceAliasIpRangeArgs']]]] = None,
- project_id: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if network is None:
- raise TypeError("Missing 'network' argument")
- if access_configs is None and 'accessConfigs' in kwargs:
- access_configs = kwargs['accessConfigs']
- if alias_ip_ranges is None and 'aliasIpRanges' in kwargs:
- alias_ip_ranges = kwargs['aliasIpRanges']
- if project_id is None and 'projectId' in kwargs:
- project_id = kwargs['projectId']
-
- _setter("network", network)
+ pulumi.set(__self__, "network", network)
if access_configs is not None:
- _setter("access_configs", access_configs)
+ pulumi.set(__self__, "access_configs", access_configs)
if alias_ip_ranges is not None:
- _setter("alias_ip_ranges", alias_ip_ranges)
+ pulumi.set(__self__, "alias_ip_ranges", alias_ip_ranges)
if project_id is not None:
- _setter("project_id", project_id)
+ pulumi.set(__self__, "project_id", project_id)
@property
@pulumi.getter
@@ -3128,23 +2236,10 @@ def __init__(__self__, *,
:param pulumi.Input[str] name: The name of the access configuration.
:param pulumi.Input[str] type: The type of the access configuration.
"""
- OceanLaunchSpecNetworkInterfaceAccessConfigArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- type=type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- type: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if type is not None:
- _setter("type", type)
+ pulumi.set(__self__, "type", type)
@property
@pulumi.getter
@@ -3182,29 +2277,8 @@ def __init__(__self__, *,
"""
- OceanLaunchSpecNetworkInterfaceAliasIpRangeArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- ip_cidr_range=ip_cidr_range,
- subnetwork_range_name=subnetwork_range_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- ip_cidr_range: Optional[pulumi.Input[str]] = None,
- subnetwork_range_name: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if ip_cidr_range is None and 'ipCidrRange' in kwargs:
- ip_cidr_range = kwargs['ipCidrRange']
- if ip_cidr_range is None:
- raise TypeError("Missing 'ip_cidr_range' argument")
- if subnetwork_range_name is None and 'subnetworkRangeName' in kwargs:
- subnetwork_range_name = kwargs['subnetworkRangeName']
- if subnetwork_range_name is None:
- raise TypeError("Missing 'subnetwork_range_name' argument")
-
- _setter("ip_cidr_range", ip_cidr_range)
- _setter("subnetwork_range_name", subnetwork_range_name)
+ pulumi.set(__self__, "ip_cidr_range", ip_cidr_range)
+ pulumi.set(__self__, "subnetwork_range_name", subnetwork_range_name)
@property
@pulumi.getter(name="ipCidrRange")
@@ -3242,27 +2316,10 @@ def __init__(__self__, *,
:param pulumi.Input[int] max_instance_count: Option to set a maximum number of instances per virtual node group. Can be null. If set, the value must be greater than or equal to 0.
:param pulumi.Input[int] min_instance_count: Option to set a minimum number of instances per virtual node group. Can be null. If set, the value must be greater than or equal to 0.
"""
- OceanLaunchSpecResourceLimitsArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- max_instance_count=max_instance_count,
- min_instance_count=min_instance_count,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- max_instance_count: Optional[pulumi.Input[int]] = None,
- min_instance_count: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if max_instance_count is None and 'maxInstanceCount' in kwargs:
- max_instance_count = kwargs['maxInstanceCount']
- if min_instance_count is None and 'minInstanceCount' in kwargs:
- min_instance_count = kwargs['minInstanceCount']
-
if max_instance_count is not None:
- _setter("max_instance_count", max_instance_count)
+ pulumi.set(__self__, "max_instance_count", max_instance_count)
if min_instance_count is not None:
- _setter("min_instance_count", min_instance_count)
+ pulumi.set(__self__, "min_instance_count", min_instance_count)
@property
@pulumi.getter(name="maxInstanceCount")
@@ -3302,42 +2359,11 @@ def __init__(__self__, *,
:param pulumi.Input[str] task_type: The activity that you are scheduling. Valid values: "manualHeadroomUpdate".
:param pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecSchedulingTaskTaskHeadroomArgs']]] task_headrooms: The config of this scheduled task. Depends on the value of taskType.
"""
- OceanLaunchSpecSchedulingTaskArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cron_expression=cron_expression,
- is_enabled=is_enabled,
- task_type=task_type,
- task_headrooms=task_headrooms,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cron_expression: Optional[pulumi.Input[str]] = None,
- is_enabled: Optional[pulumi.Input[bool]] = None,
- task_type: Optional[pulumi.Input[str]] = None,
- task_headrooms: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecSchedulingTaskTaskHeadroomArgs']]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cron_expression is None and 'cronExpression' in kwargs:
- cron_expression = kwargs['cronExpression']
- if cron_expression is None:
- raise TypeError("Missing 'cron_expression' argument")
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
- if is_enabled is None:
- raise TypeError("Missing 'is_enabled' argument")
- if task_type is None and 'taskType' in kwargs:
- task_type = kwargs['taskType']
- if task_type is None:
- raise TypeError("Missing 'task_type' argument")
- if task_headrooms is None and 'taskHeadrooms' in kwargs:
- task_headrooms = kwargs['taskHeadrooms']
-
- _setter("cron_expression", cron_expression)
- _setter("is_enabled", is_enabled)
- _setter("task_type", task_type)
+ pulumi.set(__self__, "cron_expression", cron_expression)
+ pulumi.set(__self__, "is_enabled", is_enabled)
+ pulumi.set(__self__, "task_type", task_type)
if task_headrooms is not None:
- _setter("task_headrooms", task_headrooms)
+ pulumi.set(__self__, "task_headrooms", task_headrooms)
@property
@pulumi.getter(name="cronExpression")
@@ -3401,40 +2427,13 @@ def __init__(__self__, *,
:param pulumi.Input[int] gpu_per_unit: Optionally configure the number of GPUS to allocate for each headroom unit.
:param pulumi.Input[int] memory_per_unit: Optionally configure the amount of memory (MiB) to allocate for each headroom unit.
"""
- OceanLaunchSpecSchedulingTaskTaskHeadroomArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- num_of_units=num_of_units,
- cpu_per_unit=cpu_per_unit,
- gpu_per_unit=gpu_per_unit,
- memory_per_unit=memory_per_unit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- num_of_units: Optional[pulumi.Input[int]] = None,
- cpu_per_unit: Optional[pulumi.Input[int]] = None,
- gpu_per_unit: Optional[pulumi.Input[int]] = None,
- memory_per_unit: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if num_of_units is None and 'numOfUnits' in kwargs:
- num_of_units = kwargs['numOfUnits']
- if num_of_units is None:
- raise TypeError("Missing 'num_of_units' argument")
- if cpu_per_unit is None and 'cpuPerUnit' in kwargs:
- cpu_per_unit = kwargs['cpuPerUnit']
- if gpu_per_unit is None and 'gpuPerUnit' in kwargs:
- gpu_per_unit = kwargs['gpuPerUnit']
- if memory_per_unit is None and 'memoryPerUnit' in kwargs:
- memory_per_unit = kwargs['memoryPerUnit']
-
- _setter("num_of_units", num_of_units)
+ pulumi.set(__self__, "num_of_units", num_of_units)
if cpu_per_unit is not None:
- _setter("cpu_per_unit", cpu_per_unit)
+ pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
if gpu_per_unit is not None:
- _setter("gpu_per_unit", gpu_per_unit)
+ pulumi.set(__self__, "gpu_per_unit", gpu_per_unit)
if memory_per_unit is not None:
- _setter("memory_per_unit", memory_per_unit)
+ pulumi.set(__self__, "memory_per_unit", memory_per_unit)
@property
@pulumi.getter(name="numOfUnits")
@@ -3494,27 +2493,10 @@ def __init__(__self__, *,
:param pulumi.Input[bool] enable_integrity_monitoring: Boolean. Enable the integrity monitoring parameter on the GCP instances.
:param pulumi.Input[bool] enable_secure_boot: Boolean. Enable the secure boot parameter on the GCP instances.
"""
- OceanLaunchSpecShieldedInstanceConfigArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- enable_integrity_monitoring=enable_integrity_monitoring,
- enable_secure_boot=enable_secure_boot,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- enable_integrity_monitoring: Optional[pulumi.Input[bool]] = None,
- enable_secure_boot: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if enable_integrity_monitoring is None and 'enableIntegrityMonitoring' in kwargs:
- enable_integrity_monitoring = kwargs['enableIntegrityMonitoring']
- if enable_secure_boot is None and 'enableSecureBoot' in kwargs:
- enable_secure_boot = kwargs['enableSecureBoot']
-
if enable_integrity_monitoring is not None:
- _setter("enable_integrity_monitoring", enable_integrity_monitoring)
+ pulumi.set(__self__, "enable_integrity_monitoring", enable_integrity_monitoring)
if enable_secure_boot is not None:
- _setter("enable_secure_boot", enable_secure_boot)
+ pulumi.set(__self__, "enable_secure_boot", enable_secure_boot)
@property
@pulumi.getter(name="enableIntegrityMonitoring")
@@ -3548,21 +2530,8 @@ def __init__(__self__, *,
"""
:param pulumi.Input[int] local_ssd_count: Defines the number of local SSDs to be attached per node for this VNG.
"""
- OceanLaunchSpecStorageArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- local_ssd_count=local_ssd_count,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- local_ssd_count: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if local_ssd_count is None and 'localSsdCount' in kwargs:
- local_ssd_count = kwargs['localSsdCount']
-
if local_ssd_count is not None:
- _setter("local_ssd_count", local_ssd_count)
+ pulumi.set(__self__, "local_ssd_count", local_ssd_count)
@property
@pulumi.getter(name="localSsdCount")
@@ -3584,21 +2553,8 @@ def __init__(__self__, *,
"""
:param pulumi.Input[int] preemptible_percentage: Defines the desired preemptible percentage for this launch specification.
"""
- OceanLaunchSpecStrategyArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- preemptible_percentage=preemptible_percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- preemptible_percentage: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if preemptible_percentage is None and 'preemptiblePercentage' in kwargs:
- preemptible_percentage = kwargs['preemptiblePercentage']
-
if preemptible_percentage is not None:
- _setter("preemptible_percentage", preemptible_percentage)
+ pulumi.set(__self__, "preemptible_percentage", preemptible_percentage)
@property
@pulumi.getter(name="preemptiblePercentage")
@@ -3624,27 +2580,12 @@ def __init__(__self__, *,
:param pulumi.Input[str] key: The label key.
:param pulumi.Input[str] value: The label value.
"""
- OceanLaunchSpecTaintArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- effect=effect,
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- effect: Optional[pulumi.Input[str]] = None,
- key: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if effect is not None:
- _setter("effect", effect)
+ pulumi.set(__self__, "effect", effect)
if key is not None:
- _setter("key", key)
+ pulumi.set(__self__, "key", key)
if value is not None:
- _setter("value", value)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -3688,28 +2629,9 @@ class OceanLaunchSpecUpdatePolicyArgs:
def __init__(__self__, *,
should_roll: pulumi.Input[bool],
roll_config: Optional[pulumi.Input['OceanLaunchSpecUpdatePolicyRollConfigArgs']] = None):
- OceanLaunchSpecUpdatePolicyArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- should_roll=should_roll,
- roll_config=roll_config,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- should_roll: Optional[pulumi.Input[bool]] = None,
- roll_config: Optional[pulumi.Input['OceanLaunchSpecUpdatePolicyRollConfigArgs']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if should_roll is None and 'shouldRoll' in kwargs:
- should_roll = kwargs['shouldRoll']
- if should_roll is None:
- raise TypeError("Missing 'should_roll' argument")
- if roll_config is None and 'rollConfig' in kwargs:
- roll_config = kwargs['rollConfig']
-
- _setter("should_roll", should_roll)
+ pulumi.set(__self__, "should_roll", should_roll)
if roll_config is not None:
- _setter("roll_config", roll_config)
+ pulumi.set(__self__, "roll_config", roll_config)
@property
@pulumi.getter(name="shouldRoll")
@@ -3734,22 +2656,7 @@ def roll_config(self, value: Optional[pulumi.Input['OceanLaunchSpecUpdatePolicyR
class OceanLaunchSpecUpdatePolicyRollConfigArgs:
def __init__(__self__, *,
batch_size_percentage: pulumi.Input[int]):
- OceanLaunchSpecUpdatePolicyRollConfigArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- batch_size_percentage=batch_size_percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- batch_size_percentage: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if batch_size_percentage is None and 'batchSizePercentage' in kwargs:
- batch_size_percentage = kwargs['batchSizePercentage']
- if batch_size_percentage is None:
- raise TypeError("Missing 'batch_size_percentage' argument")
-
- _setter("batch_size_percentage", batch_size_percentage)
+ pulumi.set(__self__, "batch_size_percentage", batch_size_percentage)
@property
@pulumi.getter(name="batchSizePercentage")
diff --git a/sdk/python/pulumi_spotinst/gke/elastigroup.py b/sdk/python/pulumi_spotinst/gke/elastigroup.py
index 047a7b61..9e427590 100644
--- a/sdk/python/pulumi_spotinst/gke/elastigroup.py
+++ b/sdk/python/pulumi_spotinst/gke/elastigroup.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs
from ._inputs import *
@@ -54,194 +54,69 @@ def __init__(__self__, *,
:param pulumi.Input['ElastigroupIntegrationGkeArgs'] integration_gke: Describes the GKE integration.
:param pulumi.Input[str] node_image: The image that will be used for the node VMs. Possible values: COS, UBUNTU.
"""
- ElastigroupArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cluster_zone_name=cluster_zone_name,
- desired_capacity=desired_capacity,
- backend_services=backend_services,
- cluster_id=cluster_id,
- disks=disks,
- draining_timeout=draining_timeout,
- fallback_to_ondemand=fallback_to_ondemand,
- gpu=gpu,
- instance_name_prefix=instance_name_prefix,
- instance_types_customs=instance_types_customs,
- instance_types_ondemand=instance_types_ondemand,
- instance_types_preemptibles=instance_types_preemptibles,
- integration_docker_swarm=integration_docker_swarm,
- integration_gke=integration_gke,
- ip_forwarding=ip_forwarding,
- labels=labels,
- max_size=max_size,
- metadatas=metadatas,
- min_size=min_size,
- name=name,
- network_interfaces=network_interfaces,
- node_image=node_image,
- ondemand_count=ondemand_count,
- preemptible_percentage=preemptible_percentage,
- provisioning_model=provisioning_model,
- scaling_down_policies=scaling_down_policies,
- scaling_up_policies=scaling_up_policies,
- service_account=service_account,
- shutdown_script=shutdown_script,
- startup_script=startup_script,
- tags=tags,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cluster_zone_name: Optional[pulumi.Input[str]] = None,
- desired_capacity: Optional[pulumi.Input[int]] = None,
- backend_services: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupBackendServiceArgs']]]] = None,
- cluster_id: Optional[pulumi.Input[str]] = None,
- disks: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupDiskArgs']]]] = None,
- draining_timeout: Optional[pulumi.Input[int]] = None,
- fallback_to_ondemand: Optional[pulumi.Input[bool]] = None,
- gpu: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupGpuArgs']]]] = None,
- instance_name_prefix: Optional[pulumi.Input[str]] = None,
- instance_types_customs: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupInstanceTypesCustomArgs']]]] = None,
- instance_types_ondemand: Optional[pulumi.Input[str]] = None,
- instance_types_preemptibles: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- integration_docker_swarm: Optional[pulumi.Input['ElastigroupIntegrationDockerSwarmArgs']] = None,
- integration_gke: Optional[pulumi.Input['ElastigroupIntegrationGkeArgs']] = None,
- ip_forwarding: Optional[pulumi.Input[bool]] = None,
- labels: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupLabelArgs']]]] = None,
- max_size: Optional[pulumi.Input[int]] = None,
- metadatas: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupMetadataArgs']]]] = None,
- min_size: Optional[pulumi.Input[int]] = None,
- name: Optional[pulumi.Input[str]] = None,
- network_interfaces: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceArgs']]]] = None,
- node_image: Optional[pulumi.Input[str]] = None,
- ondemand_count: Optional[pulumi.Input[int]] = None,
- preemptible_percentage: Optional[pulumi.Input[int]] = None,
- provisioning_model: Optional[pulumi.Input[str]] = None,
- scaling_down_policies: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyArgs']]]] = None,
- scaling_up_policies: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyArgs']]]] = None,
- service_account: Optional[pulumi.Input[str]] = None,
- shutdown_script: Optional[pulumi.Input[str]] = None,
- startup_script: Optional[pulumi.Input[str]] = None,
- tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cluster_zone_name is None and 'clusterZoneName' in kwargs:
- cluster_zone_name = kwargs['clusterZoneName']
- if cluster_zone_name is None:
- raise TypeError("Missing 'cluster_zone_name' argument")
- if desired_capacity is None and 'desiredCapacity' in kwargs:
- desired_capacity = kwargs['desiredCapacity']
- if desired_capacity is None:
- raise TypeError("Missing 'desired_capacity' argument")
- if backend_services is None and 'backendServices' in kwargs:
- backend_services = kwargs['backendServices']
- if cluster_id is None and 'clusterId' in kwargs:
- cluster_id = kwargs['clusterId']
- if draining_timeout is None and 'drainingTimeout' in kwargs:
- draining_timeout = kwargs['drainingTimeout']
- if fallback_to_ondemand is None and 'fallbackToOndemand' in kwargs:
- fallback_to_ondemand = kwargs['fallbackToOndemand']
- if instance_name_prefix is None and 'instanceNamePrefix' in kwargs:
- instance_name_prefix = kwargs['instanceNamePrefix']
- if instance_types_customs is None and 'instanceTypesCustoms' in kwargs:
- instance_types_customs = kwargs['instanceTypesCustoms']
- if instance_types_ondemand is None and 'instanceTypesOndemand' in kwargs:
- instance_types_ondemand = kwargs['instanceTypesOndemand']
- if instance_types_preemptibles is None and 'instanceTypesPreemptibles' in kwargs:
- instance_types_preemptibles = kwargs['instanceTypesPreemptibles']
- if integration_docker_swarm is None and 'integrationDockerSwarm' in kwargs:
- integration_docker_swarm = kwargs['integrationDockerSwarm']
- if integration_gke is None and 'integrationGke' in kwargs:
- integration_gke = kwargs['integrationGke']
- if ip_forwarding is None and 'ipForwarding' in kwargs:
- ip_forwarding = kwargs['ipForwarding']
- if max_size is None and 'maxSize' in kwargs:
- max_size = kwargs['maxSize']
- if min_size is None and 'minSize' in kwargs:
- min_size = kwargs['minSize']
- if network_interfaces is None and 'networkInterfaces' in kwargs:
- network_interfaces = kwargs['networkInterfaces']
- if node_image is None and 'nodeImage' in kwargs:
- node_image = kwargs['nodeImage']
- if ondemand_count is None and 'ondemandCount' in kwargs:
- ondemand_count = kwargs['ondemandCount']
- if preemptible_percentage is None and 'preemptiblePercentage' in kwargs:
- preemptible_percentage = kwargs['preemptiblePercentage']
- if provisioning_model is None and 'provisioningModel' in kwargs:
- provisioning_model = kwargs['provisioningModel']
- if scaling_down_policies is None and 'scalingDownPolicies' in kwargs:
- scaling_down_policies = kwargs['scalingDownPolicies']
- if scaling_up_policies is None and 'scalingUpPolicies' in kwargs:
- scaling_up_policies = kwargs['scalingUpPolicies']
- if service_account is None and 'serviceAccount' in kwargs:
- service_account = kwargs['serviceAccount']
- if shutdown_script is None and 'shutdownScript' in kwargs:
- shutdown_script = kwargs['shutdownScript']
- if startup_script is None and 'startupScript' in kwargs:
- startup_script = kwargs['startupScript']
-
- _setter("cluster_zone_name", cluster_zone_name)
- _setter("desired_capacity", desired_capacity)
+ pulumi.set(__self__, "cluster_zone_name", cluster_zone_name)
+ pulumi.set(__self__, "desired_capacity", desired_capacity)
if backend_services is not None:
- _setter("backend_services", backend_services)
+ pulumi.set(__self__, "backend_services", backend_services)
if cluster_id is not None:
warnings.warn("""Please define cluster_id under integration_gke""", DeprecationWarning)
pulumi.log.warn("""cluster_id is deprecated: Please define cluster_id under integration_gke""")
if cluster_id is not None:
- _setter("cluster_id", cluster_id)
+ pulumi.set(__self__, "cluster_id", cluster_id)
if disks is not None:
- _setter("disks", disks)
+ pulumi.set(__self__, "disks", disks)
if draining_timeout is not None:
- _setter("draining_timeout", draining_timeout)
+ pulumi.set(__self__, "draining_timeout", draining_timeout)
if fallback_to_ondemand is not None:
- _setter("fallback_to_ondemand", fallback_to_ondemand)
+ pulumi.set(__self__, "fallback_to_ondemand", fallback_to_ondemand)
if gpu is not None:
- _setter("gpu", gpu)
+ pulumi.set(__self__, "gpu", gpu)
if instance_name_prefix is not None:
- _setter("instance_name_prefix", instance_name_prefix)
+ pulumi.set(__self__, "instance_name_prefix", instance_name_prefix)
if instance_types_customs is not None:
- _setter("instance_types_customs", instance_types_customs)
+ pulumi.set(__self__, "instance_types_customs", instance_types_customs)
if instance_types_ondemand is not None:
- _setter("instance_types_ondemand", instance_types_ondemand)
+ pulumi.set(__self__, "instance_types_ondemand", instance_types_ondemand)
if instance_types_preemptibles is not None:
- _setter("instance_types_preemptibles", instance_types_preemptibles)
+ pulumi.set(__self__, "instance_types_preemptibles", instance_types_preemptibles)
if integration_docker_swarm is not None:
- _setter("integration_docker_swarm", integration_docker_swarm)
+ pulumi.set(__self__, "integration_docker_swarm", integration_docker_swarm)
if integration_gke is not None:
- _setter("integration_gke", integration_gke)
+ pulumi.set(__self__, "integration_gke", integration_gke)
if ip_forwarding is not None:
- _setter("ip_forwarding", ip_forwarding)
+ pulumi.set(__self__, "ip_forwarding", ip_forwarding)
if labels is not None:
- _setter("labels", labels)
+ pulumi.set(__self__, "labels", labels)
if max_size is not None:
- _setter("max_size", max_size)
+ pulumi.set(__self__, "max_size", max_size)
if metadatas is not None:
- _setter("metadatas", metadatas)
+ pulumi.set(__self__, "metadatas", metadatas)
if min_size is not None:
- _setter("min_size", min_size)
+ pulumi.set(__self__, "min_size", min_size)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if network_interfaces is not None:
- _setter("network_interfaces", network_interfaces)
+ pulumi.set(__self__, "network_interfaces", network_interfaces)
if node_image is not None:
- _setter("node_image", node_image)
+ pulumi.set(__self__, "node_image", node_image)
if ondemand_count is not None:
- _setter("ondemand_count", ondemand_count)
+ pulumi.set(__self__, "ondemand_count", ondemand_count)
if preemptible_percentage is not None:
- _setter("preemptible_percentage", preemptible_percentage)
+ pulumi.set(__self__, "preemptible_percentage", preemptible_percentage)
if provisioning_model is not None:
- _setter("provisioning_model", provisioning_model)
+ pulumi.set(__self__, "provisioning_model", provisioning_model)
if scaling_down_policies is not None:
- _setter("scaling_down_policies", scaling_down_policies)
+ pulumi.set(__self__, "scaling_down_policies", scaling_down_policies)
if scaling_up_policies is not None:
- _setter("scaling_up_policies", scaling_up_policies)
+ pulumi.set(__self__, "scaling_up_policies", scaling_up_policies)
if service_account is not None:
- _setter("service_account", service_account)
+ pulumi.set(__self__, "service_account", service_account)
if shutdown_script is not None:
- _setter("shutdown_script", shutdown_script)
+ pulumi.set(__self__, "shutdown_script", shutdown_script)
if startup_script is not None:
- _setter("startup_script", startup_script)
+ pulumi.set(__self__, "startup_script", startup_script)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
@property
@pulumi.getter(name="clusterZoneName")
@@ -579,192 +454,71 @@ def __init__(__self__, *,
:param pulumi.Input['ElastigroupIntegrationGkeArgs'] integration_gke: Describes the GKE integration.
:param pulumi.Input[str] node_image: The image that will be used for the node VMs. Possible values: COS, UBUNTU.
"""
- _ElastigroupState._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- backend_services=backend_services,
- cluster_id=cluster_id,
- cluster_zone_name=cluster_zone_name,
- desired_capacity=desired_capacity,
- disks=disks,
- draining_timeout=draining_timeout,
- fallback_to_ondemand=fallback_to_ondemand,
- gpu=gpu,
- instance_name_prefix=instance_name_prefix,
- instance_types_customs=instance_types_customs,
- instance_types_ondemand=instance_types_ondemand,
- instance_types_preemptibles=instance_types_preemptibles,
- integration_docker_swarm=integration_docker_swarm,
- integration_gke=integration_gke,
- ip_forwarding=ip_forwarding,
- labels=labels,
- max_size=max_size,
- metadatas=metadatas,
- min_size=min_size,
- name=name,
- network_interfaces=network_interfaces,
- node_image=node_image,
- ondemand_count=ondemand_count,
- preemptible_percentage=preemptible_percentage,
- provisioning_model=provisioning_model,
- scaling_down_policies=scaling_down_policies,
- scaling_up_policies=scaling_up_policies,
- service_account=service_account,
- shutdown_script=shutdown_script,
- startup_script=startup_script,
- tags=tags,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- backend_services: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupBackendServiceArgs']]]] = None,
- cluster_id: Optional[pulumi.Input[str]] = None,
- cluster_zone_name: Optional[pulumi.Input[str]] = None,
- desired_capacity: Optional[pulumi.Input[int]] = None,
- disks: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupDiskArgs']]]] = None,
- draining_timeout: Optional[pulumi.Input[int]] = None,
- fallback_to_ondemand: Optional[pulumi.Input[bool]] = None,
- gpu: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupGpuArgs']]]] = None,
- instance_name_prefix: Optional[pulumi.Input[str]] = None,
- instance_types_customs: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupInstanceTypesCustomArgs']]]] = None,
- instance_types_ondemand: Optional[pulumi.Input[str]] = None,
- instance_types_preemptibles: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- integration_docker_swarm: Optional[pulumi.Input['ElastigroupIntegrationDockerSwarmArgs']] = None,
- integration_gke: Optional[pulumi.Input['ElastigroupIntegrationGkeArgs']] = None,
- ip_forwarding: Optional[pulumi.Input[bool]] = None,
- labels: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupLabelArgs']]]] = None,
- max_size: Optional[pulumi.Input[int]] = None,
- metadatas: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupMetadataArgs']]]] = None,
- min_size: Optional[pulumi.Input[int]] = None,
- name: Optional[pulumi.Input[str]] = None,
- network_interfaces: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceArgs']]]] = None,
- node_image: Optional[pulumi.Input[str]] = None,
- ondemand_count: Optional[pulumi.Input[int]] = None,
- preemptible_percentage: Optional[pulumi.Input[int]] = None,
- provisioning_model: Optional[pulumi.Input[str]] = None,
- scaling_down_policies: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyArgs']]]] = None,
- scaling_up_policies: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyArgs']]]] = None,
- service_account: Optional[pulumi.Input[str]] = None,
- shutdown_script: Optional[pulumi.Input[str]] = None,
- startup_script: Optional[pulumi.Input[str]] = None,
- tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if backend_services is None and 'backendServices' in kwargs:
- backend_services = kwargs['backendServices']
- if cluster_id is None and 'clusterId' in kwargs:
- cluster_id = kwargs['clusterId']
- if cluster_zone_name is None and 'clusterZoneName' in kwargs:
- cluster_zone_name = kwargs['clusterZoneName']
- if desired_capacity is None and 'desiredCapacity' in kwargs:
- desired_capacity = kwargs['desiredCapacity']
- if draining_timeout is None and 'drainingTimeout' in kwargs:
- draining_timeout = kwargs['drainingTimeout']
- if fallback_to_ondemand is None and 'fallbackToOndemand' in kwargs:
- fallback_to_ondemand = kwargs['fallbackToOndemand']
- if instance_name_prefix is None and 'instanceNamePrefix' in kwargs:
- instance_name_prefix = kwargs['instanceNamePrefix']
- if instance_types_customs is None and 'instanceTypesCustoms' in kwargs:
- instance_types_customs = kwargs['instanceTypesCustoms']
- if instance_types_ondemand is None and 'instanceTypesOndemand' in kwargs:
- instance_types_ondemand = kwargs['instanceTypesOndemand']
- if instance_types_preemptibles is None and 'instanceTypesPreemptibles' in kwargs:
- instance_types_preemptibles = kwargs['instanceTypesPreemptibles']
- if integration_docker_swarm is None and 'integrationDockerSwarm' in kwargs:
- integration_docker_swarm = kwargs['integrationDockerSwarm']
- if integration_gke is None and 'integrationGke' in kwargs:
- integration_gke = kwargs['integrationGke']
- if ip_forwarding is None and 'ipForwarding' in kwargs:
- ip_forwarding = kwargs['ipForwarding']
- if max_size is None and 'maxSize' in kwargs:
- max_size = kwargs['maxSize']
- if min_size is None and 'minSize' in kwargs:
- min_size = kwargs['minSize']
- if network_interfaces is None and 'networkInterfaces' in kwargs:
- network_interfaces = kwargs['networkInterfaces']
- if node_image is None and 'nodeImage' in kwargs:
- node_image = kwargs['nodeImage']
- if ondemand_count is None and 'ondemandCount' in kwargs:
- ondemand_count = kwargs['ondemandCount']
- if preemptible_percentage is None and 'preemptiblePercentage' in kwargs:
- preemptible_percentage = kwargs['preemptiblePercentage']
- if provisioning_model is None and 'provisioningModel' in kwargs:
- provisioning_model = kwargs['provisioningModel']
- if scaling_down_policies is None and 'scalingDownPolicies' in kwargs:
- scaling_down_policies = kwargs['scalingDownPolicies']
- if scaling_up_policies is None and 'scalingUpPolicies' in kwargs:
- scaling_up_policies = kwargs['scalingUpPolicies']
- if service_account is None and 'serviceAccount' in kwargs:
- service_account = kwargs['serviceAccount']
- if shutdown_script is None and 'shutdownScript' in kwargs:
- shutdown_script = kwargs['shutdownScript']
- if startup_script is None and 'startupScript' in kwargs:
- startup_script = kwargs['startupScript']
-
if backend_services is not None:
- _setter("backend_services", backend_services)
+ pulumi.set(__self__, "backend_services", backend_services)
if cluster_id is not None:
warnings.warn("""Please define cluster_id under integration_gke""", DeprecationWarning)
pulumi.log.warn("""cluster_id is deprecated: Please define cluster_id under integration_gke""")
if cluster_id is not None:
- _setter("cluster_id", cluster_id)
+ pulumi.set(__self__, "cluster_id", cluster_id)
if cluster_zone_name is not None:
- _setter("cluster_zone_name", cluster_zone_name)
+ pulumi.set(__self__, "cluster_zone_name", cluster_zone_name)
if desired_capacity is not None:
- _setter("desired_capacity", desired_capacity)
+ pulumi.set(__self__, "desired_capacity", desired_capacity)
if disks is not None:
- _setter("disks", disks)
+ pulumi.set(__self__, "disks", disks)
if draining_timeout is not None:
- _setter("draining_timeout", draining_timeout)
+ pulumi.set(__self__, "draining_timeout", draining_timeout)
if fallback_to_ondemand is not None:
- _setter("fallback_to_ondemand", fallback_to_ondemand)
+ pulumi.set(__self__, "fallback_to_ondemand", fallback_to_ondemand)
if gpu is not None:
- _setter("gpu", gpu)
+ pulumi.set(__self__, "gpu", gpu)
if instance_name_prefix is not None:
- _setter("instance_name_prefix", instance_name_prefix)
+ pulumi.set(__self__, "instance_name_prefix", instance_name_prefix)
if instance_types_customs is not None:
- _setter("instance_types_customs", instance_types_customs)
+ pulumi.set(__self__, "instance_types_customs", instance_types_customs)
if instance_types_ondemand is not None:
- _setter("instance_types_ondemand", instance_types_ondemand)
+ pulumi.set(__self__, "instance_types_ondemand", instance_types_ondemand)
if instance_types_preemptibles is not None:
- _setter("instance_types_preemptibles", instance_types_preemptibles)
+ pulumi.set(__self__, "instance_types_preemptibles", instance_types_preemptibles)
if integration_docker_swarm is not None:
- _setter("integration_docker_swarm", integration_docker_swarm)
+ pulumi.set(__self__, "integration_docker_swarm", integration_docker_swarm)
if integration_gke is not None:
- _setter("integration_gke", integration_gke)
+ pulumi.set(__self__, "integration_gke", integration_gke)
if ip_forwarding is not None:
- _setter("ip_forwarding", ip_forwarding)
+ pulumi.set(__self__, "ip_forwarding", ip_forwarding)
if labels is not None:
- _setter("labels", labels)
+ pulumi.set(__self__, "labels", labels)
if max_size is not None:
- _setter("max_size", max_size)
+ pulumi.set(__self__, "max_size", max_size)
if metadatas is not None:
- _setter("metadatas", metadatas)
+ pulumi.set(__self__, "metadatas", metadatas)
if min_size is not None:
- _setter("min_size", min_size)
+ pulumi.set(__self__, "min_size", min_size)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if network_interfaces is not None:
- _setter("network_interfaces", network_interfaces)
+ pulumi.set(__self__, "network_interfaces", network_interfaces)
if node_image is not None:
- _setter("node_image", node_image)
+ pulumi.set(__self__, "node_image", node_image)
if ondemand_count is not None:
- _setter("ondemand_count", ondemand_count)
+ pulumi.set(__self__, "ondemand_count", ondemand_count)
if preemptible_percentage is not None:
- _setter("preemptible_percentage", preemptible_percentage)
+ pulumi.set(__self__, "preemptible_percentage", preemptible_percentage)
if provisioning_model is not None:
- _setter("provisioning_model", provisioning_model)
+ pulumi.set(__self__, "provisioning_model", provisioning_model)
if scaling_down_policies is not None:
- _setter("scaling_down_policies", scaling_down_policies)
+ pulumi.set(__self__, "scaling_down_policies", scaling_down_policies)
if scaling_up_policies is not None:
- _setter("scaling_up_policies", scaling_up_policies)
+ pulumi.set(__self__, "scaling_up_policies", scaling_up_policies)
if service_account is not None:
- _setter("service_account", service_account)
+ pulumi.set(__self__, "service_account", service_account)
if shutdown_script is not None:
- _setter("shutdown_script", shutdown_script)
+ pulumi.set(__self__, "shutdown_script", shutdown_script)
if startup_script is not None:
- _setter("startup_script", startup_script)
+ pulumi.set(__self__, "startup_script", startup_script)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
@property
@pulumi.getter(name="backendServices")
@@ -1241,10 +995,6 @@ def __init__(__self__, resource_name: str, *args, **kwargs):
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
- kwargs = kwargs or {}
- def _setter(key, value):
- kwargs[key] = value
- ElastigroupArgs._configure(_setter, **kwargs)
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
@@ -1306,9 +1056,7 @@ def _internal_init(__self__,
__props__.__dict__["instance_types_customs"] = instance_types_customs
__props__.__dict__["instance_types_ondemand"] = instance_types_ondemand
__props__.__dict__["instance_types_preemptibles"] = instance_types_preemptibles
- integration_docker_swarm = _utilities.configure(integration_docker_swarm, ElastigroupIntegrationDockerSwarmArgs, True)
__props__.__dict__["integration_docker_swarm"] = integration_docker_swarm
- integration_gke = _utilities.configure(integration_gke, ElastigroupIntegrationGkeArgs, True)
__props__.__dict__["integration_gke"] = integration_gke
__props__.__dict__["ip_forwarding"] = ip_forwarding
__props__.__dict__["labels"] = labels
diff --git a/sdk/python/pulumi_spotinst/gke/ocean_import.py b/sdk/python/pulumi_spotinst/gke/ocean_import.py
index 5a020247..c805d0e7 100644
--- a/sdk/python/pulumi_spotinst/gke/ocean_import.py
+++ b/sdk/python/pulumi_spotinst/gke/ocean_import.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs
from ._inputs import *
@@ -49,103 +49,36 @@ def __init__(__self__, *,
:param pulumi.Input[bool] use_as_template_only: launch specification defined on the Ocean object will function only as a template for virtual node groups.
:param pulumi.Input[Sequence[pulumi.Input[str]]] whitelists: Instance types allowed in the Ocean cluster. Cannot be configured if blacklist list is configured.
"""
- OceanImportArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cluster_name=cluster_name,
- location=location,
- autoscaler=autoscaler,
- backend_services=backend_services,
- blacklists=blacklists,
- controller_cluster_id=controller_cluster_id,
- desired_capacity=desired_capacity,
- max_size=max_size,
- min_size=min_size,
- root_volume_type=root_volume_type,
- scheduled_tasks=scheduled_tasks,
- shielded_instance_config=shielded_instance_config,
- strategies=strategies,
- update_policy=update_policy,
- use_as_template_only=use_as_template_only,
- whitelists=whitelists,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cluster_name: Optional[pulumi.Input[str]] = None,
- location: Optional[pulumi.Input[str]] = None,
- autoscaler: Optional[pulumi.Input['OceanImportAutoscalerArgs']] = None,
- backend_services: Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportBackendServiceArgs']]]] = None,
- blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- controller_cluster_id: Optional[pulumi.Input[str]] = None,
- desired_capacity: Optional[pulumi.Input[int]] = None,
- max_size: Optional[pulumi.Input[int]] = None,
- min_size: Optional[pulumi.Input[int]] = None,
- root_volume_type: Optional[pulumi.Input[str]] = None,
- scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportScheduledTaskArgs']]]] = None,
- shielded_instance_config: Optional[pulumi.Input['OceanImportShieldedInstanceConfigArgs']] = None,
- strategies: Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportStrategyArgs']]]] = None,
- update_policy: Optional[pulumi.Input['OceanImportUpdatePolicyArgs']] = None,
- use_as_template_only: Optional[pulumi.Input[bool]] = None,
- whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cluster_name is None and 'clusterName' in kwargs:
- cluster_name = kwargs['clusterName']
- if cluster_name is None:
- raise TypeError("Missing 'cluster_name' argument")
- if location is None:
- raise TypeError("Missing 'location' argument")
- if backend_services is None and 'backendServices' in kwargs:
- backend_services = kwargs['backendServices']
- if controller_cluster_id is None and 'controllerClusterId' in kwargs:
- controller_cluster_id = kwargs['controllerClusterId']
- if desired_capacity is None and 'desiredCapacity' in kwargs:
- desired_capacity = kwargs['desiredCapacity']
- if max_size is None and 'maxSize' in kwargs:
- max_size = kwargs['maxSize']
- if min_size is None and 'minSize' in kwargs:
- min_size = kwargs['minSize']
- if root_volume_type is None and 'rootVolumeType' in kwargs:
- root_volume_type = kwargs['rootVolumeType']
- if scheduled_tasks is None and 'scheduledTasks' in kwargs:
- scheduled_tasks = kwargs['scheduledTasks']
- if shielded_instance_config is None and 'shieldedInstanceConfig' in kwargs:
- shielded_instance_config = kwargs['shieldedInstanceConfig']
- if update_policy is None and 'updatePolicy' in kwargs:
- update_policy = kwargs['updatePolicy']
- if use_as_template_only is None and 'useAsTemplateOnly' in kwargs:
- use_as_template_only = kwargs['useAsTemplateOnly']
-
- _setter("cluster_name", cluster_name)
- _setter("location", location)
+ pulumi.set(__self__, "cluster_name", cluster_name)
+ pulumi.set(__self__, "location", location)
if autoscaler is not None:
- _setter("autoscaler", autoscaler)
+ pulumi.set(__self__, "autoscaler", autoscaler)
if backend_services is not None:
- _setter("backend_services", backend_services)
+ pulumi.set(__self__, "backend_services", backend_services)
if blacklists is not None:
- _setter("blacklists", blacklists)
+ pulumi.set(__self__, "blacklists", blacklists)
if controller_cluster_id is not None:
- _setter("controller_cluster_id", controller_cluster_id)
+ pulumi.set(__self__, "controller_cluster_id", controller_cluster_id)
if desired_capacity is not None:
- _setter("desired_capacity", desired_capacity)
+ pulumi.set(__self__, "desired_capacity", desired_capacity)
if max_size is not None:
- _setter("max_size", max_size)
+ pulumi.set(__self__, "max_size", max_size)
if min_size is not None:
- _setter("min_size", min_size)
+ pulumi.set(__self__, "min_size", min_size)
if root_volume_type is not None:
- _setter("root_volume_type", root_volume_type)
+ pulumi.set(__self__, "root_volume_type", root_volume_type)
if scheduled_tasks is not None:
- _setter("scheduled_tasks", scheduled_tasks)
+ pulumi.set(__self__, "scheduled_tasks", scheduled_tasks)
if shielded_instance_config is not None:
- _setter("shielded_instance_config", shielded_instance_config)
+ pulumi.set(__self__, "shielded_instance_config", shielded_instance_config)
if strategies is not None:
- _setter("strategies", strategies)
+ pulumi.set(__self__, "strategies", strategies)
if update_policy is not None:
- _setter("update_policy", update_policy)
+ pulumi.set(__self__, "update_policy", update_policy)
if use_as_template_only is not None:
- _setter("use_as_template_only", use_as_template_only)
+ pulumi.set(__self__, "use_as_template_only", use_as_template_only)
if whitelists is not None:
- _setter("whitelists", whitelists)
+ pulumi.set(__self__, "whitelists", whitelists)
@property
@pulumi.getter(name="clusterName")
@@ -371,107 +304,40 @@ def __init__(__self__, *,
:param pulumi.Input[bool] use_as_template_only: launch specification defined on the Ocean object will function only as a template for virtual node groups.
:param pulumi.Input[Sequence[pulumi.Input[str]]] whitelists: Instance types allowed in the Ocean cluster. Cannot be configured if blacklist list is configured.
"""
- _OceanImportState._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- autoscaler=autoscaler,
- backend_services=backend_services,
- blacklists=blacklists,
- cluster_controller_id=cluster_controller_id,
- cluster_name=cluster_name,
- controller_cluster_id=controller_cluster_id,
- desired_capacity=desired_capacity,
- location=location,
- max_size=max_size,
- min_size=min_size,
- root_volume_type=root_volume_type,
- scheduled_tasks=scheduled_tasks,
- shielded_instance_config=shielded_instance_config,
- strategies=strategies,
- update_policy=update_policy,
- use_as_template_only=use_as_template_only,
- whitelists=whitelists,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- autoscaler: Optional[pulumi.Input['OceanImportAutoscalerArgs']] = None,
- backend_services: Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportBackendServiceArgs']]]] = None,
- blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- cluster_controller_id: Optional[pulumi.Input[str]] = None,
- cluster_name: Optional[pulumi.Input[str]] = None,
- controller_cluster_id: Optional[pulumi.Input[str]] = None,
- desired_capacity: Optional[pulumi.Input[int]] = None,
- location: Optional[pulumi.Input[str]] = None,
- max_size: Optional[pulumi.Input[int]] = None,
- min_size: Optional[pulumi.Input[int]] = None,
- root_volume_type: Optional[pulumi.Input[str]] = None,
- scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportScheduledTaskArgs']]]] = None,
- shielded_instance_config: Optional[pulumi.Input['OceanImportShieldedInstanceConfigArgs']] = None,
- strategies: Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportStrategyArgs']]]] = None,
- update_policy: Optional[pulumi.Input['OceanImportUpdatePolicyArgs']] = None,
- use_as_template_only: Optional[pulumi.Input[bool]] = None,
- whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if backend_services is None and 'backendServices' in kwargs:
- backend_services = kwargs['backendServices']
- if cluster_controller_id is None and 'clusterControllerId' in kwargs:
- cluster_controller_id = kwargs['clusterControllerId']
- if cluster_name is None and 'clusterName' in kwargs:
- cluster_name = kwargs['clusterName']
- if controller_cluster_id is None and 'controllerClusterId' in kwargs:
- controller_cluster_id = kwargs['controllerClusterId']
- if desired_capacity is None and 'desiredCapacity' in kwargs:
- desired_capacity = kwargs['desiredCapacity']
- if max_size is None and 'maxSize' in kwargs:
- max_size = kwargs['maxSize']
- if min_size is None and 'minSize' in kwargs:
- min_size = kwargs['minSize']
- if root_volume_type is None and 'rootVolumeType' in kwargs:
- root_volume_type = kwargs['rootVolumeType']
- if scheduled_tasks is None and 'scheduledTasks' in kwargs:
- scheduled_tasks = kwargs['scheduledTasks']
- if shielded_instance_config is None and 'shieldedInstanceConfig' in kwargs:
- shielded_instance_config = kwargs['shieldedInstanceConfig']
- if update_policy is None and 'updatePolicy' in kwargs:
- update_policy = kwargs['updatePolicy']
- if use_as_template_only is None and 'useAsTemplateOnly' in kwargs:
- use_as_template_only = kwargs['useAsTemplateOnly']
-
if autoscaler is not None:
- _setter("autoscaler", autoscaler)
+ pulumi.set(__self__, "autoscaler", autoscaler)
if backend_services is not None:
- _setter("backend_services", backend_services)
+ pulumi.set(__self__, "backend_services", backend_services)
if blacklists is not None:
- _setter("blacklists", blacklists)
+ pulumi.set(__self__, "blacklists", blacklists)
if cluster_controller_id is not None:
- _setter("cluster_controller_id", cluster_controller_id)
+ pulumi.set(__self__, "cluster_controller_id", cluster_controller_id)
if cluster_name is not None:
- _setter("cluster_name", cluster_name)
+ pulumi.set(__self__, "cluster_name", cluster_name)
if controller_cluster_id is not None:
- _setter("controller_cluster_id", controller_cluster_id)
+ pulumi.set(__self__, "controller_cluster_id", controller_cluster_id)
if desired_capacity is not None:
- _setter("desired_capacity", desired_capacity)
+ pulumi.set(__self__, "desired_capacity", desired_capacity)
if location is not None:
- _setter("location", location)
+ pulumi.set(__self__, "location", location)
if max_size is not None:
- _setter("max_size", max_size)
+ pulumi.set(__self__, "max_size", max_size)
if min_size is not None:
- _setter("min_size", min_size)
+ pulumi.set(__self__, "min_size", min_size)
if root_volume_type is not None:
- _setter("root_volume_type", root_volume_type)
+ pulumi.set(__self__, "root_volume_type", root_volume_type)
if scheduled_tasks is not None:
- _setter("scheduled_tasks", scheduled_tasks)
+ pulumi.set(__self__, "scheduled_tasks", scheduled_tasks)
if shielded_instance_config is not None:
- _setter("shielded_instance_config", shielded_instance_config)
+ pulumi.set(__self__, "shielded_instance_config", shielded_instance_config)
if strategies is not None:
- _setter("strategies", strategies)
+ pulumi.set(__self__, "strategies", strategies)
if update_policy is not None:
- _setter("update_policy", update_policy)
+ pulumi.set(__self__, "update_policy", update_policy)
if use_as_template_only is not None:
- _setter("use_as_template_only", use_as_template_only)
+ pulumi.set(__self__, "use_as_template_only", use_as_template_only)
if whitelists is not None:
- _setter("whitelists", whitelists)
+ pulumi.set(__self__, "whitelists", whitelists)
@property
@pulumi.getter
@@ -890,10 +756,6 @@ def __init__(__self__, resource_name: str, *args, **kwargs):
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
- kwargs = kwargs or {}
- def _setter(key, value):
- kwargs[key] = value
- OceanImportArgs._configure(_setter, **kwargs)
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
@@ -924,7 +786,6 @@ def _internal_init(__self__,
raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
__props__ = OceanImportArgs.__new__(OceanImportArgs)
- autoscaler = _utilities.configure(autoscaler, OceanImportAutoscalerArgs, True)
__props__.__dict__["autoscaler"] = autoscaler
__props__.__dict__["backend_services"] = backend_services
__props__.__dict__["blacklists"] = blacklists
@@ -940,10 +801,8 @@ def _internal_init(__self__,
__props__.__dict__["min_size"] = min_size
__props__.__dict__["root_volume_type"] = root_volume_type
__props__.__dict__["scheduled_tasks"] = scheduled_tasks
- shielded_instance_config = _utilities.configure(shielded_instance_config, OceanImportShieldedInstanceConfigArgs, True)
__props__.__dict__["shielded_instance_config"] = shielded_instance_config
__props__.__dict__["strategies"] = strategies
- update_policy = _utilities.configure(update_policy, OceanImportUpdatePolicyArgs, True)
__props__.__dict__["update_policy"] = update_policy
__props__.__dict__["use_as_template_only"] = use_as_template_only
__props__.__dict__["whitelists"] = whitelists
diff --git a/sdk/python/pulumi_spotinst/gke/ocean_launch_spec.py b/sdk/python/pulumi_spotinst/gke/ocean_launch_spec.py
index 08afc0ad..1fa510c9 100644
--- a/sdk/python/pulumi_spotinst/gke/ocean_launch_spec.py
+++ b/sdk/python/pulumi_spotinst/gke/ocean_launch_spec.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs
from ._inputs import *
@@ -62,134 +62,49 @@ def __init__(__self__, *,
:param pulumi.Input[Sequence[pulumi.Input[str]]] tags: Every node launched from this configuration will be tagged with those tags. Note: during creation some tags are automatically imported to the state file, it is required to manually add it to the template configuration
:param pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecTaintArgs']]] taints: Optionally adds labels to instances launched in an Ocean cluster.
"""
- OceanLaunchSpecArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- ocean_id=ocean_id,
- autoscale_headrooms=autoscale_headrooms,
- autoscale_headrooms_automatics=autoscale_headrooms_automatics,
- instance_types=instance_types,
- labels=labels,
- metadatas=metadatas,
- name=name,
- network_interfaces=network_interfaces,
- node_pool_name=node_pool_name,
- resource_limits=resource_limits,
- restrict_scale_down=restrict_scale_down,
- root_volume_size=root_volume_size,
- root_volume_type=root_volume_type,
- scheduling_tasks=scheduling_tasks,
- service_account=service_account,
- shielded_instance_config=shielded_instance_config,
- source_image=source_image,
- storage=storage,
- strategies=strategies,
- tags=tags,
- taints=taints,
- update_policy=update_policy,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- ocean_id: Optional[pulumi.Input[str]] = None,
- autoscale_headrooms: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecAutoscaleHeadroomArgs']]]] = None,
- autoscale_headrooms_automatics: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecAutoscaleHeadroomsAutomaticArgs']]]] = None,
- instance_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- labels: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecLabelArgs']]]] = None,
- metadatas: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecMetadataArgs']]]] = None,
- name: Optional[pulumi.Input[str]] = None,
- network_interfaces: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecNetworkInterfaceArgs']]]] = None,
- node_pool_name: Optional[pulumi.Input[str]] = None,
- resource_limits: Optional[pulumi.Input['OceanLaunchSpecResourceLimitsArgs']] = None,
- restrict_scale_down: Optional[pulumi.Input[bool]] = None,
- root_volume_size: Optional[pulumi.Input[int]] = None,
- root_volume_type: Optional[pulumi.Input[str]] = None,
- scheduling_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecSchedulingTaskArgs']]]] = None,
- service_account: Optional[pulumi.Input[str]] = None,
- shielded_instance_config: Optional[pulumi.Input['OceanLaunchSpecShieldedInstanceConfigArgs']] = None,
- source_image: Optional[pulumi.Input[str]] = None,
- storage: Optional[pulumi.Input['OceanLaunchSpecStorageArgs']] = None,
- strategies: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecStrategyArgs']]]] = None,
- tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- taints: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecTaintArgs']]]] = None,
- update_policy: Optional[pulumi.Input['OceanLaunchSpecUpdatePolicyArgs']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if ocean_id is None and 'oceanId' in kwargs:
- ocean_id = kwargs['oceanId']
- if ocean_id is None:
- raise TypeError("Missing 'ocean_id' argument")
- if autoscale_headrooms is None and 'autoscaleHeadrooms' in kwargs:
- autoscale_headrooms = kwargs['autoscaleHeadrooms']
- if autoscale_headrooms_automatics is None and 'autoscaleHeadroomsAutomatics' in kwargs:
- autoscale_headrooms_automatics = kwargs['autoscaleHeadroomsAutomatics']
- if instance_types is None and 'instanceTypes' in kwargs:
- instance_types = kwargs['instanceTypes']
- if network_interfaces is None and 'networkInterfaces' in kwargs:
- network_interfaces = kwargs['networkInterfaces']
- if node_pool_name is None and 'nodePoolName' in kwargs:
- node_pool_name = kwargs['nodePoolName']
- if resource_limits is None and 'resourceLimits' in kwargs:
- resource_limits = kwargs['resourceLimits']
- if restrict_scale_down is None and 'restrictScaleDown' in kwargs:
- restrict_scale_down = kwargs['restrictScaleDown']
- if root_volume_size is None and 'rootVolumeSize' in kwargs:
- root_volume_size = kwargs['rootVolumeSize']
- if root_volume_type is None and 'rootVolumeType' in kwargs:
- root_volume_type = kwargs['rootVolumeType']
- if scheduling_tasks is None and 'schedulingTasks' in kwargs:
- scheduling_tasks = kwargs['schedulingTasks']
- if service_account is None and 'serviceAccount' in kwargs:
- service_account = kwargs['serviceAccount']
- if shielded_instance_config is None and 'shieldedInstanceConfig' in kwargs:
- shielded_instance_config = kwargs['shieldedInstanceConfig']
- if source_image is None and 'sourceImage' in kwargs:
- source_image = kwargs['sourceImage']
- if update_policy is None and 'updatePolicy' in kwargs:
- update_policy = kwargs['updatePolicy']
-
- _setter("ocean_id", ocean_id)
+ pulumi.set(__self__, "ocean_id", ocean_id)
if autoscale_headrooms is not None:
- _setter("autoscale_headrooms", autoscale_headrooms)
+ pulumi.set(__self__, "autoscale_headrooms", autoscale_headrooms)
if autoscale_headrooms_automatics is not None:
- _setter("autoscale_headrooms_automatics", autoscale_headrooms_automatics)
+ pulumi.set(__self__, "autoscale_headrooms_automatics", autoscale_headrooms_automatics)
if instance_types is not None:
- _setter("instance_types", instance_types)
+ pulumi.set(__self__, "instance_types", instance_types)
if labels is not None:
- _setter("labels", labels)
+ pulumi.set(__self__, "labels", labels)
if metadatas is not None:
- _setter("metadatas", metadatas)
+ pulumi.set(__self__, "metadatas", metadatas)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if network_interfaces is not None:
- _setter("network_interfaces", network_interfaces)
+ pulumi.set(__self__, "network_interfaces", network_interfaces)
if node_pool_name is not None:
- _setter("node_pool_name", node_pool_name)
+ pulumi.set(__self__, "node_pool_name", node_pool_name)
if resource_limits is not None:
- _setter("resource_limits", resource_limits)
+ pulumi.set(__self__, "resource_limits", resource_limits)
if restrict_scale_down is not None:
- _setter("restrict_scale_down", restrict_scale_down)
+ pulumi.set(__self__, "restrict_scale_down", restrict_scale_down)
if root_volume_size is not None:
- _setter("root_volume_size", root_volume_size)
+ pulumi.set(__self__, "root_volume_size", root_volume_size)
if root_volume_type is not None:
- _setter("root_volume_type", root_volume_type)
+ pulumi.set(__self__, "root_volume_type", root_volume_type)
if scheduling_tasks is not None:
- _setter("scheduling_tasks", scheduling_tasks)
+ pulumi.set(__self__, "scheduling_tasks", scheduling_tasks)
if service_account is not None:
- _setter("service_account", service_account)
+ pulumi.set(__self__, "service_account", service_account)
if shielded_instance_config is not None:
- _setter("shielded_instance_config", shielded_instance_config)
+ pulumi.set(__self__, "shielded_instance_config", shielded_instance_config)
if source_image is not None:
- _setter("source_image", source_image)
+ pulumi.set(__self__, "source_image", source_image)
if storage is not None:
- _setter("storage", storage)
+ pulumi.set(__self__, "storage", storage)
if strategies is not None:
- _setter("strategies", strategies)
+ pulumi.set(__self__, "strategies", strategies)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
if taints is not None:
- _setter("taints", taints)
+ pulumi.set(__self__, "taints", taints)
if update_policy is not None:
- _setter("update_policy", update_policy)
+ pulumi.set(__self__, "update_policy", update_policy)
@property
@pulumi.getter(name="oceanId")
@@ -502,133 +417,50 @@ def __init__(__self__, *,
:param pulumi.Input[Sequence[pulumi.Input[str]]] tags: Every node launched from this configuration will be tagged with those tags. Note: during creation some tags are automatically imported to the state file, it is required to manually add it to the template configuration
:param pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecTaintArgs']]] taints: Optionally adds labels to instances launched in an Ocean cluster.
"""
- _OceanLaunchSpecState._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- autoscale_headrooms=autoscale_headrooms,
- autoscale_headrooms_automatics=autoscale_headrooms_automatics,
- instance_types=instance_types,
- labels=labels,
- metadatas=metadatas,
- name=name,
- network_interfaces=network_interfaces,
- node_pool_name=node_pool_name,
- ocean_id=ocean_id,
- resource_limits=resource_limits,
- restrict_scale_down=restrict_scale_down,
- root_volume_size=root_volume_size,
- root_volume_type=root_volume_type,
- scheduling_tasks=scheduling_tasks,
- service_account=service_account,
- shielded_instance_config=shielded_instance_config,
- source_image=source_image,
- storage=storage,
- strategies=strategies,
- tags=tags,
- taints=taints,
- update_policy=update_policy,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- autoscale_headrooms: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecAutoscaleHeadroomArgs']]]] = None,
- autoscale_headrooms_automatics: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecAutoscaleHeadroomsAutomaticArgs']]]] = None,
- instance_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- labels: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecLabelArgs']]]] = None,
- metadatas: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecMetadataArgs']]]] = None,
- name: Optional[pulumi.Input[str]] = None,
- network_interfaces: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecNetworkInterfaceArgs']]]] = None,
- node_pool_name: Optional[pulumi.Input[str]] = None,
- ocean_id: Optional[pulumi.Input[str]] = None,
- resource_limits: Optional[pulumi.Input['OceanLaunchSpecResourceLimitsArgs']] = None,
- restrict_scale_down: Optional[pulumi.Input[bool]] = None,
- root_volume_size: Optional[pulumi.Input[int]] = None,
- root_volume_type: Optional[pulumi.Input[str]] = None,
- scheduling_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecSchedulingTaskArgs']]]] = None,
- service_account: Optional[pulumi.Input[str]] = None,
- shielded_instance_config: Optional[pulumi.Input['OceanLaunchSpecShieldedInstanceConfigArgs']] = None,
- source_image: Optional[pulumi.Input[str]] = None,
- storage: Optional[pulumi.Input['OceanLaunchSpecStorageArgs']] = None,
- strategies: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecStrategyArgs']]]] = None,
- tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- taints: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecTaintArgs']]]] = None,
- update_policy: Optional[pulumi.Input['OceanLaunchSpecUpdatePolicyArgs']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if autoscale_headrooms is None and 'autoscaleHeadrooms' in kwargs:
- autoscale_headrooms = kwargs['autoscaleHeadrooms']
- if autoscale_headrooms_automatics is None and 'autoscaleHeadroomsAutomatics' in kwargs:
- autoscale_headrooms_automatics = kwargs['autoscaleHeadroomsAutomatics']
- if instance_types is None and 'instanceTypes' in kwargs:
- instance_types = kwargs['instanceTypes']
- if network_interfaces is None and 'networkInterfaces' in kwargs:
- network_interfaces = kwargs['networkInterfaces']
- if node_pool_name is None and 'nodePoolName' in kwargs:
- node_pool_name = kwargs['nodePoolName']
- if ocean_id is None and 'oceanId' in kwargs:
- ocean_id = kwargs['oceanId']
- if resource_limits is None and 'resourceLimits' in kwargs:
- resource_limits = kwargs['resourceLimits']
- if restrict_scale_down is None and 'restrictScaleDown' in kwargs:
- restrict_scale_down = kwargs['restrictScaleDown']
- if root_volume_size is None and 'rootVolumeSize' in kwargs:
- root_volume_size = kwargs['rootVolumeSize']
- if root_volume_type is None and 'rootVolumeType' in kwargs:
- root_volume_type = kwargs['rootVolumeType']
- if scheduling_tasks is None and 'schedulingTasks' in kwargs:
- scheduling_tasks = kwargs['schedulingTasks']
- if service_account is None and 'serviceAccount' in kwargs:
- service_account = kwargs['serviceAccount']
- if shielded_instance_config is None and 'shieldedInstanceConfig' in kwargs:
- shielded_instance_config = kwargs['shieldedInstanceConfig']
- if source_image is None and 'sourceImage' in kwargs:
- source_image = kwargs['sourceImage']
- if update_policy is None and 'updatePolicy' in kwargs:
- update_policy = kwargs['updatePolicy']
-
if autoscale_headrooms is not None:
- _setter("autoscale_headrooms", autoscale_headrooms)
+ pulumi.set(__self__, "autoscale_headrooms", autoscale_headrooms)
if autoscale_headrooms_automatics is not None:
- _setter("autoscale_headrooms_automatics", autoscale_headrooms_automatics)
+ pulumi.set(__self__, "autoscale_headrooms_automatics", autoscale_headrooms_automatics)
if instance_types is not None:
- _setter("instance_types", instance_types)
+ pulumi.set(__self__, "instance_types", instance_types)
if labels is not None:
- _setter("labels", labels)
+ pulumi.set(__self__, "labels", labels)
if metadatas is not None:
- _setter("metadatas", metadatas)
+ pulumi.set(__self__, "metadatas", metadatas)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if network_interfaces is not None:
- _setter("network_interfaces", network_interfaces)
+ pulumi.set(__self__, "network_interfaces", network_interfaces)
if node_pool_name is not None:
- _setter("node_pool_name", node_pool_name)
+ pulumi.set(__self__, "node_pool_name", node_pool_name)
if ocean_id is not None:
- _setter("ocean_id", ocean_id)
+ pulumi.set(__self__, "ocean_id", ocean_id)
if resource_limits is not None:
- _setter("resource_limits", resource_limits)
+ pulumi.set(__self__, "resource_limits", resource_limits)
if restrict_scale_down is not None:
- _setter("restrict_scale_down", restrict_scale_down)
+ pulumi.set(__self__, "restrict_scale_down", restrict_scale_down)
if root_volume_size is not None:
- _setter("root_volume_size", root_volume_size)
+ pulumi.set(__self__, "root_volume_size", root_volume_size)
if root_volume_type is not None:
- _setter("root_volume_type", root_volume_type)
+ pulumi.set(__self__, "root_volume_type", root_volume_type)
if scheduling_tasks is not None:
- _setter("scheduling_tasks", scheduling_tasks)
+ pulumi.set(__self__, "scheduling_tasks", scheduling_tasks)
if service_account is not None:
- _setter("service_account", service_account)
+ pulumi.set(__self__, "service_account", service_account)
if shielded_instance_config is not None:
- _setter("shielded_instance_config", shielded_instance_config)
+ pulumi.set(__self__, "shielded_instance_config", shielded_instance_config)
if source_image is not None:
- _setter("source_image", source_image)
+ pulumi.set(__self__, "source_image", source_image)
if storage is not None:
- _setter("storage", storage)
+ pulumi.set(__self__, "storage", storage)
if strategies is not None:
- _setter("strategies", strategies)
+ pulumi.set(__self__, "strategies", strategies)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
if taints is not None:
- _setter("taints", taints)
+ pulumi.set(__self__, "taints", taints)
if update_policy is not None:
- _setter("update_policy", update_policy)
+ pulumi.set(__self__, "update_policy", update_policy)
@property
@pulumi.getter(name="autoscaleHeadrooms")
@@ -1160,10 +992,6 @@ def __init__(__self__, resource_name: str, *args, **kwargs):
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
- kwargs = kwargs or {}
- def _setter(key, value):
- kwargs[key] = value
- OceanLaunchSpecArgs._configure(_setter, **kwargs)
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
@@ -1211,22 +1039,18 @@ def _internal_init(__self__,
if ocean_id is None and not opts.urn:
raise TypeError("Missing required property 'ocean_id'")
__props__.__dict__["ocean_id"] = ocean_id
- resource_limits = _utilities.configure(resource_limits, OceanLaunchSpecResourceLimitsArgs, True)
__props__.__dict__["resource_limits"] = resource_limits
__props__.__dict__["restrict_scale_down"] = restrict_scale_down
__props__.__dict__["root_volume_size"] = root_volume_size
__props__.__dict__["root_volume_type"] = root_volume_type
__props__.__dict__["scheduling_tasks"] = scheduling_tasks
__props__.__dict__["service_account"] = service_account
- shielded_instance_config = _utilities.configure(shielded_instance_config, OceanLaunchSpecShieldedInstanceConfigArgs, True)
__props__.__dict__["shielded_instance_config"] = shielded_instance_config
__props__.__dict__["source_image"] = source_image
- storage = _utilities.configure(storage, OceanLaunchSpecStorageArgs, True)
__props__.__dict__["storage"] = storage
__props__.__dict__["strategies"] = strategies
__props__.__dict__["tags"] = tags
__props__.__dict__["taints"] = taints
- update_policy = _utilities.configure(update_policy, OceanLaunchSpecUpdatePolicyArgs, True)
__props__.__dict__["update_policy"] = update_policy
super(OceanLaunchSpec, __self__).__init__(
'spotinst:gke/oceanLaunchSpec:OceanLaunchSpec',
diff --git a/sdk/python/pulumi_spotinst/gke/ocean_launch_spec_import.py b/sdk/python/pulumi_spotinst/gke/ocean_launch_spec_import.py
index 53ba0b6f..ff493639 100644
--- a/sdk/python/pulumi_spotinst/gke/ocean_launch_spec_import.py
+++ b/sdk/python/pulumi_spotinst/gke/ocean_launch_spec_import.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
__all__ = ['OceanLaunchSpecImportArgs', 'OceanLaunchSpecImport']
@@ -21,29 +21,8 @@ def __init__(__self__, *,
:param pulumi.Input[str] node_pool_name: The node pool you wish to use in your launchSpec.
:param pulumi.Input[str] ocean_id: The Ocean cluster ID required for launchSpec create.
"""
- OceanLaunchSpecImportArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- node_pool_name=node_pool_name,
- ocean_id=ocean_id,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- node_pool_name: Optional[pulumi.Input[str]] = None,
- ocean_id: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if node_pool_name is None and 'nodePoolName' in kwargs:
- node_pool_name = kwargs['nodePoolName']
- if node_pool_name is None:
- raise TypeError("Missing 'node_pool_name' argument")
- if ocean_id is None and 'oceanId' in kwargs:
- ocean_id = kwargs['oceanId']
- if ocean_id is None:
- raise TypeError("Missing 'ocean_id' argument")
-
- _setter("node_pool_name", node_pool_name)
- _setter("ocean_id", ocean_id)
+ pulumi.set(__self__, "node_pool_name", node_pool_name)
+ pulumi.set(__self__, "ocean_id", ocean_id)
@property
@pulumi.getter(name="nodePoolName")
@@ -80,27 +59,10 @@ def __init__(__self__, *,
:param pulumi.Input[str] node_pool_name: The node pool you wish to use in your launchSpec.
:param pulumi.Input[str] ocean_id: The Ocean cluster ID required for launchSpec create.
"""
- _OceanLaunchSpecImportState._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- node_pool_name=node_pool_name,
- ocean_id=ocean_id,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- node_pool_name: Optional[pulumi.Input[str]] = None,
- ocean_id: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if node_pool_name is None and 'nodePoolName' in kwargs:
- node_pool_name = kwargs['nodePoolName']
- if ocean_id is None and 'oceanId' in kwargs:
- ocean_id = kwargs['oceanId']
-
if node_pool_name is not None:
- _setter("node_pool_name", node_pool_name)
+ pulumi.set(__self__, "node_pool_name", node_pool_name)
if ocean_id is not None:
- _setter("ocean_id", ocean_id)
+ pulumi.set(__self__, "ocean_id", ocean_id)
@property
@pulumi.getter(name="nodePoolName")
@@ -194,10 +156,6 @@ def __init__(__self__, resource_name: str, *args, **kwargs):
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
- kwargs = kwargs or {}
- def _setter(key, value):
- kwargs[key] = value
- OceanLaunchSpecImportArgs._configure(_setter, **kwargs)
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
diff --git a/sdk/python/pulumi_spotinst/gke/outputs.py b/sdk/python/pulumi_spotinst/gke/outputs.py
index 11f596b5..45aa51a1 100644
--- a/sdk/python/pulumi_spotinst/gke/outputs.py
+++ b/sdk/python/pulumi_spotinst/gke/outputs.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs
@@ -92,38 +92,13 @@ def __init__(__self__, *,
location_type: Optional[str] = None,
named_ports: Optional[Sequence['outputs.ElastigroupBackendServiceNamedPort']] = None,
scheme: Optional[str] = None):
- ElastigroupBackendService._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- service_name=service_name,
- location_type=location_type,
- named_ports=named_ports,
- scheme=scheme,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- service_name: Optional[str] = None,
- location_type: Optional[str] = None,
- named_ports: Optional[Sequence['outputs.ElastigroupBackendServiceNamedPort']] = None,
- scheme: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if service_name is None and 'serviceName' in kwargs:
- service_name = kwargs['serviceName']
- if service_name is None:
- raise TypeError("Missing 'service_name' argument")
- if location_type is None and 'locationType' in kwargs:
- location_type = kwargs['locationType']
- if named_ports is None and 'namedPorts' in kwargs:
- named_ports = kwargs['namedPorts']
-
- _setter("service_name", service_name)
+ pulumi.set(__self__, "service_name", service_name)
if location_type is not None:
- _setter("location_type", location_type)
+ pulumi.set(__self__, "location_type", location_type)
if named_ports is not None:
- _setter("named_ports", named_ports)
+ pulumi.set(__self__, "named_ports", named_ports)
if scheme is not None:
- _setter("scheme", scheme)
+ pulumi.set(__self__, "scheme", scheme)
@property
@pulumi.getter(name="serviceName")
@@ -151,25 +126,8 @@ class ElastigroupBackendServiceNamedPort(dict):
def __init__(__self__, *,
name: str,
ports: Sequence[str]):
- ElastigroupBackendServiceNamedPort._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- ports=ports,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[str] = None,
- ports: Optional[Sequence[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
- if ports is None:
- raise TypeError("Missing 'ports' argument")
-
- _setter("name", name)
- _setter("ports", ports)
+ pulumi.set(__self__, "name", name)
+ pulumi.set(__self__, "ports", ports)
@property
@pulumi.getter
@@ -214,53 +172,22 @@ def __init__(__self__, *,
mode: Optional[str] = None,
source: Optional[str] = None,
type: Optional[str] = None):
- ElastigroupDisk._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- auto_delete=auto_delete,
- boot=boot,
- device_name=device_name,
- initialize_params=initialize_params,
- interface=interface,
- mode=mode,
- source=source,
- type=type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- auto_delete: Optional[bool] = None,
- boot: Optional[bool] = None,
- device_name: Optional[str] = None,
- initialize_params: Optional[Sequence['outputs.ElastigroupDiskInitializeParam']] = None,
- interface: Optional[str] = None,
- mode: Optional[str] = None,
- source: Optional[str] = None,
- type: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if auto_delete is None and 'autoDelete' in kwargs:
- auto_delete = kwargs['autoDelete']
- if device_name is None and 'deviceName' in kwargs:
- device_name = kwargs['deviceName']
- if initialize_params is None and 'initializeParams' in kwargs:
- initialize_params = kwargs['initializeParams']
-
if auto_delete is not None:
- _setter("auto_delete", auto_delete)
+ pulumi.set(__self__, "auto_delete", auto_delete)
if boot is not None:
- _setter("boot", boot)
+ pulumi.set(__self__, "boot", boot)
if device_name is not None:
- _setter("device_name", device_name)
+ pulumi.set(__self__, "device_name", device_name)
if initialize_params is not None:
- _setter("initialize_params", initialize_params)
+ pulumi.set(__self__, "initialize_params", initialize_params)
if interface is not None:
- _setter("interface", interface)
+ pulumi.set(__self__, "interface", interface)
if mode is not None:
- _setter("mode", mode)
+ pulumi.set(__self__, "mode", mode)
if source is not None:
- _setter("source", source)
+ pulumi.set(__self__, "source", source)
if type is not None:
- _setter("type", type)
+ pulumi.set(__self__, "type", type)
@property
@pulumi.getter(name="autoDelete")
@@ -330,34 +257,11 @@ def __init__(__self__, *,
source_image: str,
disk_size_gb: Optional[str] = None,
disk_type: Optional[str] = None):
- ElastigroupDiskInitializeParam._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- source_image=source_image,
- disk_size_gb=disk_size_gb,
- disk_type=disk_type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- source_image: Optional[str] = None,
- disk_size_gb: Optional[str] = None,
- disk_type: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if source_image is None and 'sourceImage' in kwargs:
- source_image = kwargs['sourceImage']
- if source_image is None:
- raise TypeError("Missing 'source_image' argument")
- if disk_size_gb is None and 'diskSizeGb' in kwargs:
- disk_size_gb = kwargs['diskSizeGb']
- if disk_type is None and 'diskType' in kwargs:
- disk_type = kwargs['diskType']
-
- _setter("source_image", source_image)
+ pulumi.set(__self__, "source_image", source_image)
if disk_size_gb is not None:
- _setter("disk_size_gb", disk_size_gb)
+ pulumi.set(__self__, "disk_size_gb", disk_size_gb)
if disk_type is not None:
- _setter("disk_type", disk_type)
+ pulumi.set(__self__, "disk_type", disk_type)
@property
@pulumi.getter(name="sourceImage")
@@ -380,25 +284,8 @@ class ElastigroupGpu(dict):
def __init__(__self__, *,
count: int,
type: str):
- ElastigroupGpu._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- count=count,
- type=type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- count: Optional[int] = None,
- type: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if count is None:
- raise TypeError("Missing 'count' argument")
- if type is None:
- raise TypeError("Missing 'type' argument")
-
- _setter("count", count)
- _setter("type", type)
+ pulumi.set(__self__, "count", count)
+ pulumi.set(__self__, "type", type)
@property
@pulumi.getter
@@ -433,27 +320,8 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
memory_gib: int,
vcpu: int):
- ElastigroupInstanceTypesCustom._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- memory_gib=memory_gib,
- vcpu=vcpu,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- memory_gib: Optional[int] = None,
- vcpu: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if memory_gib is None and 'memoryGib' in kwargs:
- memory_gib = kwargs['memoryGib']
- if memory_gib is None:
- raise TypeError("Missing 'memory_gib' argument")
- if vcpu is None:
- raise TypeError("Missing 'vcpu' argument")
-
- _setter("memory_gib", memory_gib)
- _setter("vcpu", vcpu)
+ pulumi.set(__self__, "memory_gib", memory_gib)
+ pulumi.set(__self__, "vcpu", vcpu)
@property
@pulumi.getter(name="memoryGib")
@@ -490,29 +358,8 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
master_host: str,
master_port: int):
- ElastigroupIntegrationDockerSwarm._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- master_host=master_host,
- master_port=master_port,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- master_host: Optional[str] = None,
- master_port: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if master_host is None and 'masterHost' in kwargs:
- master_host = kwargs['masterHost']
- if master_host is None:
- raise TypeError("Missing 'master_host' argument")
- if master_port is None and 'masterPort' in kwargs:
- master_port = kwargs['masterPort']
- if master_port is None:
- raise TypeError("Missing 'master_port' argument")
-
- _setter("master_host", master_host)
- _setter("master_port", master_port)
+ pulumi.set(__self__, "master_host", master_host)
+ pulumi.set(__self__, "master_port", master_port)
@property
@pulumi.getter(name="masterHost")
@@ -577,67 +424,24 @@ def __init__(__self__, *,
:param str cluster_id: The name of the GKE cluster you wish to import.
:param str location: The location of your GKE cluster.
"""
- ElastigroupIntegrationGke._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- auto_update=auto_update,
- autoscale_cooldown=autoscale_cooldown,
- autoscale_down=autoscale_down,
- autoscale_headroom=autoscale_headroom,
- autoscale_is_auto_config=autoscale_is_auto_config,
- autoscale_is_enabled=autoscale_is_enabled,
- autoscale_labels=autoscale_labels,
- cluster_id=cluster_id,
- location=location,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- auto_update: Optional[bool] = None,
- autoscale_cooldown: Optional[int] = None,
- autoscale_down: Optional['outputs.ElastigroupIntegrationGkeAutoscaleDown'] = None,
- autoscale_headroom: Optional['outputs.ElastigroupIntegrationGkeAutoscaleHeadroom'] = None,
- autoscale_is_auto_config: Optional[bool] = None,
- autoscale_is_enabled: Optional[bool] = None,
- autoscale_labels: Optional[Sequence['outputs.ElastigroupIntegrationGkeAutoscaleLabel']] = None,
- cluster_id: Optional[str] = None,
- location: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if auto_update is None and 'autoUpdate' in kwargs:
- auto_update = kwargs['autoUpdate']
- if autoscale_cooldown is None and 'autoscaleCooldown' in kwargs:
- autoscale_cooldown = kwargs['autoscaleCooldown']
- if autoscale_down is None and 'autoscaleDown' in kwargs:
- autoscale_down = kwargs['autoscaleDown']
- if autoscale_headroom is None and 'autoscaleHeadroom' in kwargs:
- autoscale_headroom = kwargs['autoscaleHeadroom']
- if autoscale_is_auto_config is None and 'autoscaleIsAutoConfig' in kwargs:
- autoscale_is_auto_config = kwargs['autoscaleIsAutoConfig']
- if autoscale_is_enabled is None and 'autoscaleIsEnabled' in kwargs:
- autoscale_is_enabled = kwargs['autoscaleIsEnabled']
- if autoscale_labels is None and 'autoscaleLabels' in kwargs:
- autoscale_labels = kwargs['autoscaleLabels']
- if cluster_id is None and 'clusterId' in kwargs:
- cluster_id = kwargs['clusterId']
-
if auto_update is not None:
- _setter("auto_update", auto_update)
+ pulumi.set(__self__, "auto_update", auto_update)
if autoscale_cooldown is not None:
- _setter("autoscale_cooldown", autoscale_cooldown)
+ pulumi.set(__self__, "autoscale_cooldown", autoscale_cooldown)
if autoscale_down is not None:
- _setter("autoscale_down", autoscale_down)
+ pulumi.set(__self__, "autoscale_down", autoscale_down)
if autoscale_headroom is not None:
- _setter("autoscale_headroom", autoscale_headroom)
+ pulumi.set(__self__, "autoscale_headroom", autoscale_headroom)
if autoscale_is_auto_config is not None:
- _setter("autoscale_is_auto_config", autoscale_is_auto_config)
+ pulumi.set(__self__, "autoscale_is_auto_config", autoscale_is_auto_config)
if autoscale_is_enabled is not None:
- _setter("autoscale_is_enabled", autoscale_is_enabled)
+ pulumi.set(__self__, "autoscale_is_enabled", autoscale_is_enabled)
if autoscale_labels is not None:
- _setter("autoscale_labels", autoscale_labels)
+ pulumi.set(__self__, "autoscale_labels", autoscale_labels)
if cluster_id is not None:
- _setter("cluster_id", cluster_id)
+ pulumi.set(__self__, "cluster_id", cluster_id)
if location is not None:
- _setter("location", location)
+ pulumi.set(__self__, "location", location)
@property
@pulumi.getter(name="autoUpdate")
@@ -730,21 +534,8 @@ def __init__(__self__, *,
"""
:param int evaluation_periods: Amount of cooldown evaluation periods for scale down.
"""
- ElastigroupIntegrationGkeAutoscaleDown._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- evaluation_periods=evaluation_periods,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- evaluation_periods: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
-
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
@property
@pulumi.getter(name="evaluationPeriods")
@@ -787,33 +578,12 @@ def __init__(__self__, *,
:param int memory_per_unit: RAM units for compute.
:param int num_of_units: Amount of units for compute.
"""
- ElastigroupIntegrationGkeAutoscaleHeadroom._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cpu_per_unit=cpu_per_unit,
- memory_per_unit=memory_per_unit,
- num_of_units=num_of_units,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cpu_per_unit: Optional[int] = None,
- memory_per_unit: Optional[int] = None,
- num_of_units: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cpu_per_unit is None and 'cpuPerUnit' in kwargs:
- cpu_per_unit = kwargs['cpuPerUnit']
- if memory_per_unit is None and 'memoryPerUnit' in kwargs:
- memory_per_unit = kwargs['memoryPerUnit']
- if num_of_units is None and 'numOfUnits' in kwargs:
- num_of_units = kwargs['numOfUnits']
-
if cpu_per_unit is not None:
- _setter("cpu_per_unit", cpu_per_unit)
+ pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
if memory_per_unit is not None:
- _setter("memory_per_unit", memory_per_unit)
+ pulumi.set(__self__, "memory_per_unit", memory_per_unit)
if num_of_units is not None:
- _setter("num_of_units", num_of_units)
+ pulumi.set(__self__, "num_of_units", num_of_units)
@property
@pulumi.getter(name="cpuPerUnit")
@@ -845,25 +615,8 @@ class ElastigroupIntegrationGkeAutoscaleLabel(dict):
def __init__(__self__, *,
key: str,
value: str):
- ElastigroupIntegrationGkeAutoscaleLabel._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -881,25 +634,8 @@ class ElastigroupLabel(dict):
def __init__(__self__, *,
key: str,
value: str):
- ElastigroupLabel._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -917,25 +653,8 @@ class ElastigroupMetadata(dict):
def __init__(__self__, *,
key: str,
value: str):
- ElastigroupMetadata._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -973,32 +692,11 @@ def __init__(__self__, *,
network: str,
access_configs: Optional[Sequence['outputs.ElastigroupNetworkInterfaceAccessConfig']] = None,
alias_ip_ranges: Optional[Sequence['outputs.ElastigroupNetworkInterfaceAliasIpRange']] = None):
- ElastigroupNetworkInterface._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- network=network,
- access_configs=access_configs,
- alias_ip_ranges=alias_ip_ranges,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- network: Optional[str] = None,
- access_configs: Optional[Sequence['outputs.ElastigroupNetworkInterfaceAccessConfig']] = None,
- alias_ip_ranges: Optional[Sequence['outputs.ElastigroupNetworkInterfaceAliasIpRange']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if network is None:
- raise TypeError("Missing 'network' argument")
- if access_configs is None and 'accessConfigs' in kwargs:
- access_configs = kwargs['accessConfigs']
- if alias_ip_ranges is None and 'aliasIpRanges' in kwargs:
- alias_ip_ranges = kwargs['aliasIpRanges']
-
- _setter("network", network)
+ pulumi.set(__self__, "network", network)
if access_configs is not None:
- _setter("access_configs", access_configs)
+ pulumi.set(__self__, "access_configs", access_configs)
if alias_ip_ranges is not None:
- _setter("alias_ip_ranges", alias_ip_ranges)
+ pulumi.set(__self__, "alias_ip_ranges", alias_ip_ranges)
@property
@pulumi.getter
@@ -1021,23 +719,10 @@ class ElastigroupNetworkInterfaceAccessConfig(dict):
def __init__(__self__, *,
name: Optional[str] = None,
type: Optional[str] = None):
- ElastigroupNetworkInterfaceAccessConfig._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- type=type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[str] = None,
- type: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if type is not None:
- _setter("type", type)
+ pulumi.set(__self__, "type", type)
@property
@pulumi.getter
@@ -1074,29 +759,8 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
ip_cidr_range: str,
subnetwork_range_name: str):
- ElastigroupNetworkInterfaceAliasIpRange._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- ip_cidr_range=ip_cidr_range,
- subnetwork_range_name=subnetwork_range_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- ip_cidr_range: Optional[str] = None,
- subnetwork_range_name: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if ip_cidr_range is None and 'ipCidrRange' in kwargs:
- ip_cidr_range = kwargs['ipCidrRange']
- if ip_cidr_range is None:
- raise TypeError("Missing 'ip_cidr_range' argument")
- if subnetwork_range_name is None and 'subnetworkRangeName' in kwargs:
- subnetwork_range_name = kwargs['subnetworkRangeName']
- if subnetwork_range_name is None:
- raise TypeError("Missing 'subnetwork_range_name' argument")
-
- _setter("ip_cidr_range", ip_cidr_range)
- _setter("subnetwork_range_name", subnetwork_range_name)
+ pulumi.set(__self__, "ip_cidr_range", ip_cidr_range)
+ pulumi.set(__self__, "subnetwork_range_name", subnetwork_range_name)
@property
@pulumi.getter(name="ipCidrRange")
@@ -1152,84 +816,29 @@ def __init__(__self__, *,
"""
:param int evaluation_periods: Amount of cooldown evaluation periods for scale down.
"""
- ElastigroupScalingDownPolicy._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- metric_name=metric_name,
- namespace=namespace,
- policy_name=policy_name,
- threshold=threshold,
- unit=unit,
- action_type=action_type,
- adjustment=adjustment,
- cooldown=cooldown,
- dimensions=dimensions,
- evaluation_periods=evaluation_periods,
- operator=operator,
- period=period,
- source=source,
- statistic=statistic,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- metric_name: Optional[str] = None,
- namespace: Optional[str] = None,
- policy_name: Optional[str] = None,
- threshold: Optional[float] = None,
- unit: Optional[str] = None,
- action_type: Optional[str] = None,
- adjustment: Optional[int] = None,
- cooldown: Optional[int] = None,
- dimensions: Optional[Sequence['outputs.ElastigroupScalingDownPolicyDimension']] = None,
- evaluation_periods: Optional[int] = None,
- operator: Optional[str] = None,
- period: Optional[int] = None,
- source: Optional[str] = None,
- statistic: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if metric_name is None and 'metricName' in kwargs:
- metric_name = kwargs['metricName']
- if metric_name is None:
- raise TypeError("Missing 'metric_name' argument")
- if namespace is None:
- raise TypeError("Missing 'namespace' argument")
- if policy_name is None and 'policyName' in kwargs:
- policy_name = kwargs['policyName']
- if policy_name is None:
- raise TypeError("Missing 'policy_name' argument")
- if threshold is None:
- raise TypeError("Missing 'threshold' argument")
- if unit is None:
- raise TypeError("Missing 'unit' argument")
- if action_type is None and 'actionType' in kwargs:
- action_type = kwargs['actionType']
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
-
- _setter("metric_name", metric_name)
- _setter("namespace", namespace)
- _setter("policy_name", policy_name)
- _setter("threshold", threshold)
- _setter("unit", unit)
+ pulumi.set(__self__, "metric_name", metric_name)
+ pulumi.set(__self__, "namespace", namespace)
+ pulumi.set(__self__, "policy_name", policy_name)
+ pulumi.set(__self__, "threshold", threshold)
+ pulumi.set(__self__, "unit", unit)
if action_type is not None:
- _setter("action_type", action_type)
+ pulumi.set(__self__, "action_type", action_type)
if adjustment is not None:
- _setter("adjustment", adjustment)
+ pulumi.set(__self__, "adjustment", adjustment)
if cooldown is not None:
- _setter("cooldown", cooldown)
+ pulumi.set(__self__, "cooldown", cooldown)
if dimensions is not None:
- _setter("dimensions", dimensions)
+ pulumi.set(__self__, "dimensions", dimensions)
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
if operator is not None:
- _setter("operator", operator)
+ pulumi.set(__self__, "operator", operator)
if period is not None:
- _setter("period", period)
+ pulumi.set(__self__, "period", period)
if source is not None:
- _setter("source", source)
+ pulumi.set(__self__, "source", source)
if statistic is not None:
- _setter("statistic", statistic)
+ pulumi.set(__self__, "statistic", statistic)
@property
@pulumi.getter(name="metricName")
@@ -1310,24 +919,9 @@ class ElastigroupScalingDownPolicyDimension(dict):
def __init__(__self__, *,
name: str,
value: Optional[str] = None):
- ElastigroupScalingDownPolicyDimension._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
-
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if value is not None:
- _setter("value", value)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -1383,84 +977,29 @@ def __init__(__self__, *,
"""
:param int evaluation_periods: Amount of cooldown evaluation periods for scale down.
"""
- ElastigroupScalingUpPolicy._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- metric_name=metric_name,
- namespace=namespace,
- policy_name=policy_name,
- threshold=threshold,
- unit=unit,
- action_type=action_type,
- adjustment=adjustment,
- cooldown=cooldown,
- dimensions=dimensions,
- evaluation_periods=evaluation_periods,
- operator=operator,
- period=period,
- source=source,
- statistic=statistic,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- metric_name: Optional[str] = None,
- namespace: Optional[str] = None,
- policy_name: Optional[str] = None,
- threshold: Optional[float] = None,
- unit: Optional[str] = None,
- action_type: Optional[str] = None,
- adjustment: Optional[int] = None,
- cooldown: Optional[int] = None,
- dimensions: Optional[Sequence['outputs.ElastigroupScalingUpPolicyDimension']] = None,
- evaluation_periods: Optional[int] = None,
- operator: Optional[str] = None,
- period: Optional[int] = None,
- source: Optional[str] = None,
- statistic: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if metric_name is None and 'metricName' in kwargs:
- metric_name = kwargs['metricName']
- if metric_name is None:
- raise TypeError("Missing 'metric_name' argument")
- if namespace is None:
- raise TypeError("Missing 'namespace' argument")
- if policy_name is None and 'policyName' in kwargs:
- policy_name = kwargs['policyName']
- if policy_name is None:
- raise TypeError("Missing 'policy_name' argument")
- if threshold is None:
- raise TypeError("Missing 'threshold' argument")
- if unit is None:
- raise TypeError("Missing 'unit' argument")
- if action_type is None and 'actionType' in kwargs:
- action_type = kwargs['actionType']
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
-
- _setter("metric_name", metric_name)
- _setter("namespace", namespace)
- _setter("policy_name", policy_name)
- _setter("threshold", threshold)
- _setter("unit", unit)
+ pulumi.set(__self__, "metric_name", metric_name)
+ pulumi.set(__self__, "namespace", namespace)
+ pulumi.set(__self__, "policy_name", policy_name)
+ pulumi.set(__self__, "threshold", threshold)
+ pulumi.set(__self__, "unit", unit)
if action_type is not None:
- _setter("action_type", action_type)
+ pulumi.set(__self__, "action_type", action_type)
if adjustment is not None:
- _setter("adjustment", adjustment)
+ pulumi.set(__self__, "adjustment", adjustment)
if cooldown is not None:
- _setter("cooldown", cooldown)
+ pulumi.set(__self__, "cooldown", cooldown)
if dimensions is not None:
- _setter("dimensions", dimensions)
+ pulumi.set(__self__, "dimensions", dimensions)
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
if operator is not None:
- _setter("operator", operator)
+ pulumi.set(__self__, "operator", operator)
if period is not None:
- _setter("period", period)
+ pulumi.set(__self__, "period", period)
if source is not None:
- _setter("source", source)
+ pulumi.set(__self__, "source", source)
if statistic is not None:
- _setter("statistic", statistic)
+ pulumi.set(__self__, "statistic", statistic)
@property
@pulumi.getter(name="metricName")
@@ -1541,24 +1080,9 @@ class ElastigroupScalingUpPolicyDimension(dict):
def __init__(__self__, *,
name: str,
value: Optional[str] = None):
- ElastigroupScalingUpPolicyDimension._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
-
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if value is not None:
- _setter("value", value)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -1617,57 +1141,22 @@ def __init__(__self__, *,
:param bool is_enabled: Enable the Ocean Kubernetes Autoscaler.
:param 'OceanImportAutoscalerResourceLimitsArgs' resource_limits: Optionally set upper and lower bounds on the resource usage of the cluster.
"""
- OceanImportAutoscaler._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- auto_headroom_percentage=auto_headroom_percentage,
- cooldown=cooldown,
- down=down,
- enable_automatic_and_manual_headroom=enable_automatic_and_manual_headroom,
- headroom=headroom,
- is_auto_config=is_auto_config,
- is_enabled=is_enabled,
- resource_limits=resource_limits,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- auto_headroom_percentage: Optional[int] = None,
- cooldown: Optional[int] = None,
- down: Optional['outputs.OceanImportAutoscalerDown'] = None,
- enable_automatic_and_manual_headroom: Optional[bool] = None,
- headroom: Optional['outputs.OceanImportAutoscalerHeadroom'] = None,
- is_auto_config: Optional[bool] = None,
- is_enabled: Optional[bool] = None,
- resource_limits: Optional['outputs.OceanImportAutoscalerResourceLimits'] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if auto_headroom_percentage is None and 'autoHeadroomPercentage' in kwargs:
- auto_headroom_percentage = kwargs['autoHeadroomPercentage']
- if enable_automatic_and_manual_headroom is None and 'enableAutomaticAndManualHeadroom' in kwargs:
- enable_automatic_and_manual_headroom = kwargs['enableAutomaticAndManualHeadroom']
- if is_auto_config is None and 'isAutoConfig' in kwargs:
- is_auto_config = kwargs['isAutoConfig']
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
- if resource_limits is None and 'resourceLimits' in kwargs:
- resource_limits = kwargs['resourceLimits']
-
if auto_headroom_percentage is not None:
- _setter("auto_headroom_percentage", auto_headroom_percentage)
+ pulumi.set(__self__, "auto_headroom_percentage", auto_headroom_percentage)
if cooldown is not None:
- _setter("cooldown", cooldown)
+ pulumi.set(__self__, "cooldown", cooldown)
if down is not None:
- _setter("down", down)
+ pulumi.set(__self__, "down", down)
if enable_automatic_and_manual_headroom is not None:
- _setter("enable_automatic_and_manual_headroom", enable_automatic_and_manual_headroom)
+ pulumi.set(__self__, "enable_automatic_and_manual_headroom", enable_automatic_and_manual_headroom)
if headroom is not None:
- _setter("headroom", headroom)
+ pulumi.set(__self__, "headroom", headroom)
if is_auto_config is not None:
- _setter("is_auto_config", is_auto_config)
+ pulumi.set(__self__, "is_auto_config", is_auto_config)
if is_enabled is not None:
- _setter("is_enabled", is_enabled)
+ pulumi.set(__self__, "is_enabled", is_enabled)
if resource_limits is not None:
- _setter("resource_limits", resource_limits)
+ pulumi.set(__self__, "resource_limits", resource_limits)
@property
@pulumi.getter(name="autoHeadroomPercentage")
@@ -1762,27 +1251,10 @@ def __init__(__self__, *,
:param int evaluation_periods: The number of evaluation periods that should accumulate before a scale down action takes place.
:param float max_scale_down_percentage: Would represent the maximum % to scale-down. Number between 1-100.
"""
- OceanImportAutoscalerDown._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- evaluation_periods=evaluation_periods,
- max_scale_down_percentage=max_scale_down_percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- evaluation_periods: Optional[int] = None,
- max_scale_down_percentage: Optional[float] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if evaluation_periods is None and 'evaluationPeriods' in kwargs:
- evaluation_periods = kwargs['evaluationPeriods']
- if max_scale_down_percentage is None and 'maxScaleDownPercentage' in kwargs:
- max_scale_down_percentage = kwargs['maxScaleDownPercentage']
-
if evaluation_periods is not None:
- _setter("evaluation_periods", evaluation_periods)
+ pulumi.set(__self__, "evaluation_periods", evaluation_periods)
if max_scale_down_percentage is not None:
- _setter("max_scale_down_percentage", max_scale_down_percentage)
+ pulumi.set(__self__, "max_scale_down_percentage", max_scale_down_percentage)
@property
@pulumi.getter(name="evaluationPeriods")
@@ -1837,39 +1309,14 @@ def __init__(__self__, *,
:param int memory_per_unit: Optionally configure the amount of memory (MiB) to allocate the headroom.
:param int num_of_units: The number of units to retain as headroom, where each unit has the defined headroom CPU and memory.
"""
- OceanImportAutoscalerHeadroom._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cpu_per_unit=cpu_per_unit,
- gpu_per_unit=gpu_per_unit,
- memory_per_unit=memory_per_unit,
- num_of_units=num_of_units,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cpu_per_unit: Optional[int] = None,
- gpu_per_unit: Optional[int] = None,
- memory_per_unit: Optional[int] = None,
- num_of_units: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cpu_per_unit is None and 'cpuPerUnit' in kwargs:
- cpu_per_unit = kwargs['cpuPerUnit']
- if gpu_per_unit is None and 'gpuPerUnit' in kwargs:
- gpu_per_unit = kwargs['gpuPerUnit']
- if memory_per_unit is None and 'memoryPerUnit' in kwargs:
- memory_per_unit = kwargs['memoryPerUnit']
- if num_of_units is None and 'numOfUnits' in kwargs:
- num_of_units = kwargs['numOfUnits']
-
if cpu_per_unit is not None:
- _setter("cpu_per_unit", cpu_per_unit)
+ pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
if gpu_per_unit is not None:
- _setter("gpu_per_unit", gpu_per_unit)
+ pulumi.set(__self__, "gpu_per_unit", gpu_per_unit)
if memory_per_unit is not None:
- _setter("memory_per_unit", memory_per_unit)
+ pulumi.set(__self__, "memory_per_unit", memory_per_unit)
if num_of_units is not None:
- _setter("num_of_units", num_of_units)
+ pulumi.set(__self__, "num_of_units", num_of_units)
@property
@pulumi.getter(name="cpuPerUnit")
@@ -1938,27 +1385,10 @@ def __init__(__self__, *,
:param int max_vcpu: The maximum cpu in vCpu units that can be allocated to the cluster.
"""
- OceanImportAutoscalerResourceLimits._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- max_memory_gib=max_memory_gib,
- max_vcpu=max_vcpu,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- max_memory_gib: Optional[int] = None,
- max_vcpu: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if max_memory_gib is None and 'maxMemoryGib' in kwargs:
- max_memory_gib = kwargs['maxMemoryGib']
- if max_vcpu is None and 'maxVcpu' in kwargs:
- max_vcpu = kwargs['maxVcpu']
-
if max_memory_gib is not None:
- _setter("max_memory_gib", max_memory_gib)
+ pulumi.set(__self__, "max_memory_gib", max_memory_gib)
if max_vcpu is not None:
- _setter("max_vcpu", max_vcpu)
+ pulumi.set(__self__, "max_vcpu", max_vcpu)
@property
@pulumi.getter(name="maxMemoryGib")
@@ -2016,38 +1446,13 @@ def __init__(__self__, *,
:param str location_type: Sets which location the backend services will be active. Valid values: `regional`, `global`.
:param str scheme: Use when `location_type` is `regional`. Set the traffic for the backend service to either between the instances in the vpc or to traffic from the internet. Valid values: `INTERNAL`, `EXTERNAL`.
"""
- OceanImportBackendService._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- service_name=service_name,
- location_type=location_type,
- named_ports=named_ports,
- scheme=scheme,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- service_name: Optional[str] = None,
- location_type: Optional[str] = None,
- named_ports: Optional[Sequence['outputs.OceanImportBackendServiceNamedPort']] = None,
- scheme: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if service_name is None and 'serviceName' in kwargs:
- service_name = kwargs['serviceName']
- if service_name is None:
- raise TypeError("Missing 'service_name' argument")
- if location_type is None and 'locationType' in kwargs:
- location_type = kwargs['locationType']
- if named_ports is None and 'namedPorts' in kwargs:
- named_ports = kwargs['namedPorts']
-
- _setter("service_name", service_name)
+ pulumi.set(__self__, "service_name", service_name)
if location_type is not None:
- _setter("location_type", location_type)
+ pulumi.set(__self__, "location_type", location_type)
if named_ports is not None:
- _setter("named_ports", named_ports)
+ pulumi.set(__self__, "named_ports", named_ports)
if scheme is not None:
- _setter("scheme", scheme)
+ pulumi.set(__self__, "scheme", scheme)
@property
@pulumi.getter(name="serviceName")
@@ -2087,25 +1492,8 @@ def __init__(__self__, *,
"""
:param Sequence[str] ports: A list of ports.
"""
- OceanImportBackendServiceNamedPort._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- ports=ports,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[str] = None,
- ports: Optional[Sequence[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
- if ports is None:
- raise TypeError("Missing 'ports' argument")
-
- _setter("name", name)
- _setter("ports", ports)
+ pulumi.set(__self__, "name", name)
+ pulumi.set(__self__, "ports", ports)
@property
@pulumi.getter
@@ -2147,25 +1535,10 @@ def __init__(__self__, *,
:param 'OceanImportScheduledTaskShutdownHoursArgs' shutdown_hours: Set shutdown hours for cluster object.
:param Sequence['OceanImportScheduledTaskTaskArgs'] tasks: The scheduling tasks for the cluster.
"""
- OceanImportScheduledTask._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- shutdown_hours=shutdown_hours,
- tasks=tasks,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- shutdown_hours: Optional['outputs.OceanImportScheduledTaskShutdownHours'] = None,
- tasks: Optional[Sequence['outputs.OceanImportScheduledTaskTask']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if shutdown_hours is None and 'shutdownHours' in kwargs:
- shutdown_hours = kwargs['shutdownHours']
-
if shutdown_hours is not None:
- _setter("shutdown_hours", shutdown_hours)
+ pulumi.set(__self__, "shutdown_hours", shutdown_hours)
if tasks is not None:
- _setter("tasks", tasks)
+ pulumi.set(__self__, "tasks", tasks)
@property
@pulumi.getter(name="shutdownHours")
@@ -2213,28 +1586,9 @@ def __init__(__self__, *,
Example: Fri:15:30-Wed:14:30
:param bool is_enabled: Enable the Ocean Kubernetes Autoscaler.
"""
- OceanImportScheduledTaskShutdownHours._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- time_windows=time_windows,
- is_enabled=is_enabled,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- time_windows: Optional[Sequence[str]] = None,
- is_enabled: Optional[bool] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if time_windows is None and 'timeWindows' in kwargs:
- time_windows = kwargs['timeWindows']
- if time_windows is None:
- raise TypeError("Missing 'time_windows' argument")
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
-
- _setter("time_windows", time_windows)
+ pulumi.set(__self__, "time_windows", time_windows)
if is_enabled is not None:
- _setter("is_enabled", is_enabled)
+ pulumi.set(__self__, "is_enabled", is_enabled)
@property
@pulumi.getter(name="timeWindows")
@@ -2290,42 +1644,11 @@ def __init__(__self__, *,
:param bool is_enabled: Enable the Ocean Kubernetes Autoscaler.
:param str task_type: Valid values: "clusterRoll". Required for cluster.scheduling.tasks object.
"""
- OceanImportScheduledTaskTask._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cron_expression=cron_expression,
- is_enabled=is_enabled,
- task_type=task_type,
- task_parameters=task_parameters,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cron_expression: Optional[str] = None,
- is_enabled: Optional[bool] = None,
- task_type: Optional[str] = None,
- task_parameters: Optional['outputs.OceanImportScheduledTaskTaskTaskParameters'] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cron_expression is None and 'cronExpression' in kwargs:
- cron_expression = kwargs['cronExpression']
- if cron_expression is None:
- raise TypeError("Missing 'cron_expression' argument")
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
- if is_enabled is None:
- raise TypeError("Missing 'is_enabled' argument")
- if task_type is None and 'taskType' in kwargs:
- task_type = kwargs['taskType']
- if task_type is None:
- raise TypeError("Missing 'task_type' argument")
- if task_parameters is None and 'taskParameters' in kwargs:
- task_parameters = kwargs['taskParameters']
-
- _setter("cron_expression", cron_expression)
- _setter("is_enabled", is_enabled)
- _setter("task_type", task_type)
+ pulumi.set(__self__, "cron_expression", cron_expression)
+ pulumi.set(__self__, "is_enabled", is_enabled)
+ pulumi.set(__self__, "task_type", task_type)
if task_parameters is not None:
- _setter("task_parameters", task_parameters)
+ pulumi.set(__self__, "task_parameters", task_parameters)
@property
@pulumi.getter(name="cronExpression")
@@ -2379,21 +1702,8 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
cluster_roll: Optional['outputs.OceanImportScheduledTaskTaskTaskParametersClusterRoll'] = None):
- OceanImportScheduledTaskTaskTaskParameters._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cluster_roll=cluster_roll,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cluster_roll: Optional['outputs.OceanImportScheduledTaskTaskTaskParametersClusterRoll'] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cluster_roll is None and 'clusterRoll' in kwargs:
- cluster_roll = kwargs['clusterRoll']
-
if cluster_roll is not None:
- _setter("cluster_roll", cluster_roll)
+ pulumi.set(__self__, "cluster_roll", cluster_roll)
@property
@pulumi.getter(name="clusterRoll")
@@ -2437,37 +1747,14 @@ def __init__(__self__, *,
import pulumi
```
"""
- OceanImportScheduledTaskTaskTaskParametersClusterRoll._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- batch_min_healthy_percentage=batch_min_healthy_percentage,
- batch_size_percentage=batch_size_percentage,
- comment=comment,
- respect_pdb=respect_pdb,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- batch_min_healthy_percentage: Optional[int] = None,
- batch_size_percentage: Optional[int] = None,
- comment: Optional[str] = None,
- respect_pdb: Optional[bool] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if batch_min_healthy_percentage is None and 'batchMinHealthyPercentage' in kwargs:
- batch_min_healthy_percentage = kwargs['batchMinHealthyPercentage']
- if batch_size_percentage is None and 'batchSizePercentage' in kwargs:
- batch_size_percentage = kwargs['batchSizePercentage']
- if respect_pdb is None and 'respectPdb' in kwargs:
- respect_pdb = kwargs['respectPdb']
-
if batch_min_healthy_percentage is not None:
- _setter("batch_min_healthy_percentage", batch_min_healthy_percentage)
+ pulumi.set(__self__, "batch_min_healthy_percentage", batch_min_healthy_percentage)
if batch_size_percentage is not None:
- _setter("batch_size_percentage", batch_size_percentage)
+ pulumi.set(__self__, "batch_size_percentage", batch_size_percentage)
if comment is not None:
- _setter("comment", comment)
+ pulumi.set(__self__, "comment", comment)
if respect_pdb is not None:
- _setter("respect_pdb", respect_pdb)
+ pulumi.set(__self__, "respect_pdb", respect_pdb)
@property
@pulumi.getter(name="batchMinHealthyPercentage")
@@ -2526,27 +1813,10 @@ def __init__(__self__, *,
:param bool enable_integrity_monitoring: Boolean. Enable the integrity monitoring parameter on the GCP instances.
:param bool enable_secure_boot: Boolean. Enable the secure boot parameter on the GCP instances.
"""
- OceanImportShieldedInstanceConfig._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- enable_integrity_monitoring=enable_integrity_monitoring,
- enable_secure_boot=enable_secure_boot,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- enable_integrity_monitoring: Optional[bool] = None,
- enable_secure_boot: Optional[bool] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if enable_integrity_monitoring is None and 'enableIntegrityMonitoring' in kwargs:
- enable_integrity_monitoring = kwargs['enableIntegrityMonitoring']
- if enable_secure_boot is None and 'enableSecureBoot' in kwargs:
- enable_secure_boot = kwargs['enableSecureBoot']
-
if enable_integrity_monitoring is not None:
- _setter("enable_integrity_monitoring", enable_integrity_monitoring)
+ pulumi.set(__self__, "enable_integrity_monitoring", enable_integrity_monitoring)
if enable_secure_boot is not None:
- _setter("enable_secure_boot", enable_secure_boot)
+ pulumi.set(__self__, "enable_secure_boot", enable_secure_boot)
@property
@pulumi.getter(name="enableIntegrityMonitoring")
@@ -2595,33 +1865,12 @@ def __init__(__self__, *,
"""
:param int draining_timeout: The draining timeout (in seconds) before terminating the instance.
"""
- OceanImportStrategy._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- draining_timeout=draining_timeout,
- preemptible_percentage=preemptible_percentage,
- provisioning_model=provisioning_model,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- draining_timeout: Optional[int] = None,
- preemptible_percentage: Optional[int] = None,
- provisioning_model: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if draining_timeout is None and 'drainingTimeout' in kwargs:
- draining_timeout = kwargs['drainingTimeout']
- if preemptible_percentage is None and 'preemptiblePercentage' in kwargs:
- preemptible_percentage = kwargs['preemptiblePercentage']
- if provisioning_model is None and 'provisioningModel' in kwargs:
- provisioning_model = kwargs['provisioningModel']
-
if draining_timeout is not None:
- _setter("draining_timeout", draining_timeout)
+ pulumi.set(__self__, "draining_timeout", draining_timeout)
if preemptible_percentage is not None:
- _setter("preemptible_percentage", preemptible_percentage)
+ pulumi.set(__self__, "preemptible_percentage", preemptible_percentage)
if provisioning_model is not None:
- _setter("provisioning_model", provisioning_model)
+ pulumi.set(__self__, "provisioning_model", provisioning_model)
@property
@pulumi.getter(name="drainingTimeout")
@@ -2669,34 +1918,11 @@ def __init__(__self__, *,
should_roll: bool,
conditioned_roll: Optional[bool] = None,
roll_config: Optional['outputs.OceanImportUpdatePolicyRollConfig'] = None):
- OceanImportUpdatePolicy._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- should_roll=should_roll,
- conditioned_roll=conditioned_roll,
- roll_config=roll_config,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- should_roll: Optional[bool] = None,
- conditioned_roll: Optional[bool] = None,
- roll_config: Optional['outputs.OceanImportUpdatePolicyRollConfig'] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if should_roll is None and 'shouldRoll' in kwargs:
- should_roll = kwargs['shouldRoll']
- if should_roll is None:
- raise TypeError("Missing 'should_roll' argument")
- if conditioned_roll is None and 'conditionedRoll' in kwargs:
- conditioned_roll = kwargs['conditionedRoll']
- if roll_config is None and 'rollConfig' in kwargs:
- roll_config = kwargs['rollConfig']
-
- _setter("should_roll", should_roll)
+ pulumi.set(__self__, "should_roll", should_roll)
if conditioned_roll is not None:
- _setter("conditioned_roll", conditioned_roll)
+ pulumi.set(__self__, "conditioned_roll", conditioned_roll)
if roll_config is not None:
- _setter("roll_config", roll_config)
+ pulumi.set(__self__, "roll_config", roll_config)
@property
@pulumi.getter(name="shouldRoll")
@@ -2752,40 +1978,13 @@ def __init__(__self__, *,
import pulumi
```
"""
- OceanImportUpdatePolicyRollConfig._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- batch_size_percentage=batch_size_percentage,
- batch_min_healthy_percentage=batch_min_healthy_percentage,
- launch_spec_ids=launch_spec_ids,
- respect_pdb=respect_pdb,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- batch_size_percentage: Optional[int] = None,
- batch_min_healthy_percentage: Optional[int] = None,
- launch_spec_ids: Optional[Sequence[str]] = None,
- respect_pdb: Optional[bool] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if batch_size_percentage is None and 'batchSizePercentage' in kwargs:
- batch_size_percentage = kwargs['batchSizePercentage']
- if batch_size_percentage is None:
- raise TypeError("Missing 'batch_size_percentage' argument")
- if batch_min_healthy_percentage is None and 'batchMinHealthyPercentage' in kwargs:
- batch_min_healthy_percentage = kwargs['batchMinHealthyPercentage']
- if launch_spec_ids is None and 'launchSpecIds' in kwargs:
- launch_spec_ids = kwargs['launchSpecIds']
- if respect_pdb is None and 'respectPdb' in kwargs:
- respect_pdb = kwargs['respectPdb']
-
- _setter("batch_size_percentage", batch_size_percentage)
+ pulumi.set(__self__, "batch_size_percentage", batch_size_percentage)
if batch_min_healthy_percentage is not None:
- _setter("batch_min_healthy_percentage", batch_min_healthy_percentage)
+ pulumi.set(__self__, "batch_min_healthy_percentage", batch_min_healthy_percentage)
if launch_spec_ids is not None:
- _setter("launch_spec_ids", launch_spec_ids)
+ pulumi.set(__self__, "launch_spec_ids", launch_spec_ids)
if respect_pdb is not None:
- _setter("respect_pdb", respect_pdb)
+ pulumi.set(__self__, "respect_pdb", respect_pdb)
@property
@pulumi.getter(name="batchSizePercentage")
@@ -2852,40 +2051,13 @@ def __init__(__self__, *,
:param int gpu_per_unit: Optionally configure the number of GPUS to allocate for each headroom unit.
:param int memory_per_unit: Optionally configure the amount of memory (MiB) to allocate for each headroom unit.
"""
- OceanLaunchSpecAutoscaleHeadroom._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- num_of_units=num_of_units,
- cpu_per_unit=cpu_per_unit,
- gpu_per_unit=gpu_per_unit,
- memory_per_unit=memory_per_unit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- num_of_units: Optional[int] = None,
- cpu_per_unit: Optional[int] = None,
- gpu_per_unit: Optional[int] = None,
- memory_per_unit: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if num_of_units is None and 'numOfUnits' in kwargs:
- num_of_units = kwargs['numOfUnits']
- if num_of_units is None:
- raise TypeError("Missing 'num_of_units' argument")
- if cpu_per_unit is None and 'cpuPerUnit' in kwargs:
- cpu_per_unit = kwargs['cpuPerUnit']
- if gpu_per_unit is None and 'gpuPerUnit' in kwargs:
- gpu_per_unit = kwargs['gpuPerUnit']
- if memory_per_unit is None and 'memoryPerUnit' in kwargs:
- memory_per_unit = kwargs['memoryPerUnit']
-
- _setter("num_of_units", num_of_units)
+ pulumi.set(__self__, "num_of_units", num_of_units)
if cpu_per_unit is not None:
- _setter("cpu_per_unit", cpu_per_unit)
+ pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
if gpu_per_unit is not None:
- _setter("gpu_per_unit", gpu_per_unit)
+ pulumi.set(__self__, "gpu_per_unit", gpu_per_unit)
if memory_per_unit is not None:
- _setter("memory_per_unit", memory_per_unit)
+ pulumi.set(__self__, "memory_per_unit", memory_per_unit)
@property
@pulumi.getter(name="numOfUnits")
@@ -2944,21 +2116,8 @@ def __init__(__self__, *,
"""
:param int auto_headroom_percentage: Number between 0-200 to control the headroom % of the specific Virtual Node Group. Effective when cluster.autoScaler.headroom.automatic.`is_enabled` = true is set on the Ocean cluster.
"""
- OceanLaunchSpecAutoscaleHeadroomsAutomatic._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- auto_headroom_percentage=auto_headroom_percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- auto_headroom_percentage: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if auto_headroom_percentage is None and 'autoHeadroomPercentage' in kwargs:
- auto_headroom_percentage = kwargs['autoHeadroomPercentage']
-
if auto_headroom_percentage is not None:
- _setter("auto_headroom_percentage", auto_headroom_percentage)
+ pulumi.set(__self__, "auto_headroom_percentage", auto_headroom_percentage)
@property
@pulumi.getter(name="autoHeadroomPercentage")
@@ -2978,23 +2137,10 @@ def __init__(__self__, *,
:param str key: The label key.
:param str value: The label value.
"""
- OceanLaunchSpecLabel._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if key is not None:
- _setter("key", key)
+ pulumi.set(__self__, "key", key)
if value is not None:
- _setter("value", value)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -3022,23 +2168,10 @@ def __init__(__self__, *,
:param str key: The label key.
:param str value: The label value.
"""
- OceanLaunchSpecMetadata._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if key is not None:
- _setter("key", key)
+ pulumi.set(__self__, "key", key)
if value is not None:
- _setter("value", value)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -3091,38 +2224,13 @@ def __init__(__self__, *,
:param Sequence['OceanLaunchSpecNetworkInterfaceAliasIpRangeArgs'] alias_ip_ranges: use the imported node pool’s associated aliasIpRange to assign secondary IP addresses to the nodes. Cannot be changed after VNG creation.
:param str project_id: Use a network resource from a different project. Set the project identifier to use its network resource. This parameter is relevant only if the network resource is in a different project.
"""
- OceanLaunchSpecNetworkInterface._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- network=network,
- access_configs=access_configs,
- alias_ip_ranges=alias_ip_ranges,
- project_id=project_id,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- network: Optional[str] = None,
- access_configs: Optional[Sequence['outputs.OceanLaunchSpecNetworkInterfaceAccessConfig']] = None,
- alias_ip_ranges: Optional[Sequence['outputs.OceanLaunchSpecNetworkInterfaceAliasIpRange']] = None,
- project_id: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if network is None:
- raise TypeError("Missing 'network' argument")
- if access_configs is None and 'accessConfigs' in kwargs:
- access_configs = kwargs['accessConfigs']
- if alias_ip_ranges is None and 'aliasIpRanges' in kwargs:
- alias_ip_ranges = kwargs['aliasIpRanges']
- if project_id is None and 'projectId' in kwargs:
- project_id = kwargs['projectId']
-
- _setter("network", network)
+ pulumi.set(__self__, "network", network)
if access_configs is not None:
- _setter("access_configs", access_configs)
+ pulumi.set(__self__, "access_configs", access_configs)
if alias_ip_ranges is not None:
- _setter("alias_ip_ranges", alias_ip_ranges)
+ pulumi.set(__self__, "alias_ip_ranges", alias_ip_ranges)
if project_id is not None:
- _setter("project_id", project_id)
+ pulumi.set(__self__, "project_id", project_id)
@property
@pulumi.getter
@@ -3166,23 +2274,10 @@ def __init__(__self__, *,
:param str name: The name of the access configuration.
:param str type: The type of the access configuration.
"""
- OceanLaunchSpecNetworkInterfaceAccessConfig._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- type=type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[str] = None,
- type: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if type is not None:
- _setter("type", type)
+ pulumi.set(__self__, "type", type)
@property
@pulumi.getter
@@ -3231,29 +2326,8 @@ def __init__(__self__, *,
"""
- OceanLaunchSpecNetworkInterfaceAliasIpRange._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- ip_cidr_range=ip_cidr_range,
- subnetwork_range_name=subnetwork_range_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- ip_cidr_range: Optional[str] = None,
- subnetwork_range_name: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if ip_cidr_range is None and 'ipCidrRange' in kwargs:
- ip_cidr_range = kwargs['ipCidrRange']
- if ip_cidr_range is None:
- raise TypeError("Missing 'ip_cidr_range' argument")
- if subnetwork_range_name is None and 'subnetworkRangeName' in kwargs:
- subnetwork_range_name = kwargs['subnetworkRangeName']
- if subnetwork_range_name is None:
- raise TypeError("Missing 'subnetwork_range_name' argument")
-
- _setter("ip_cidr_range", ip_cidr_range)
- _setter("subnetwork_range_name", subnetwork_range_name)
+ pulumi.set(__self__, "ip_cidr_range", ip_cidr_range)
+ pulumi.set(__self__, "subnetwork_range_name", subnetwork_range_name)
@property
@pulumi.getter(name="ipCidrRange")
@@ -3302,27 +2376,10 @@ def __init__(__self__, *,
:param int max_instance_count: Option to set a maximum number of instances per virtual node group. Can be null. If set, the value must be greater than or equal to 0.
:param int min_instance_count: Option to set a minimum number of instances per virtual node group. Can be null. If set, the value must be greater than or equal to 0.
"""
- OceanLaunchSpecResourceLimits._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- max_instance_count=max_instance_count,
- min_instance_count=min_instance_count,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- max_instance_count: Optional[int] = None,
- min_instance_count: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if max_instance_count is None and 'maxInstanceCount' in kwargs:
- max_instance_count = kwargs['maxInstanceCount']
- if min_instance_count is None and 'minInstanceCount' in kwargs:
- min_instance_count = kwargs['minInstanceCount']
-
if max_instance_count is not None:
- _setter("max_instance_count", max_instance_count)
+ pulumi.set(__self__, "max_instance_count", max_instance_count)
if min_instance_count is not None:
- _setter("min_instance_count", min_instance_count)
+ pulumi.set(__self__, "min_instance_count", min_instance_count)
@property
@pulumi.getter(name="maxInstanceCount")
@@ -3377,42 +2434,11 @@ def __init__(__self__, *,
:param str task_type: The activity that you are scheduling. Valid values: "manualHeadroomUpdate".
:param Sequence['OceanLaunchSpecSchedulingTaskTaskHeadroomArgs'] task_headrooms: The config of this scheduled task. Depends on the value of taskType.
"""
- OceanLaunchSpecSchedulingTask._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cron_expression=cron_expression,
- is_enabled=is_enabled,
- task_type=task_type,
- task_headrooms=task_headrooms,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cron_expression: Optional[str] = None,
- is_enabled: Optional[bool] = None,
- task_type: Optional[str] = None,
- task_headrooms: Optional[Sequence['outputs.OceanLaunchSpecSchedulingTaskTaskHeadroom']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cron_expression is None and 'cronExpression' in kwargs:
- cron_expression = kwargs['cronExpression']
- if cron_expression is None:
- raise TypeError("Missing 'cron_expression' argument")
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
- if is_enabled is None:
- raise TypeError("Missing 'is_enabled' argument")
- if task_type is None and 'taskType' in kwargs:
- task_type = kwargs['taskType']
- if task_type is None:
- raise TypeError("Missing 'task_type' argument")
- if task_headrooms is None and 'taskHeadrooms' in kwargs:
- task_headrooms = kwargs['taskHeadrooms']
-
- _setter("cron_expression", cron_expression)
- _setter("is_enabled", is_enabled)
- _setter("task_type", task_type)
+ pulumi.set(__self__, "cron_expression", cron_expression)
+ pulumi.set(__self__, "is_enabled", is_enabled)
+ pulumi.set(__self__, "task_type", task_type)
if task_headrooms is not None:
- _setter("task_headrooms", task_headrooms)
+ pulumi.set(__self__, "task_headrooms", task_headrooms)
@property
@pulumi.getter(name="cronExpression")
@@ -3483,40 +2509,13 @@ def __init__(__self__, *,
:param int gpu_per_unit: Optionally configure the number of GPUS to allocate for each headroom unit.
:param int memory_per_unit: Optionally configure the amount of memory (MiB) to allocate for each headroom unit.
"""
- OceanLaunchSpecSchedulingTaskTaskHeadroom._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- num_of_units=num_of_units,
- cpu_per_unit=cpu_per_unit,
- gpu_per_unit=gpu_per_unit,
- memory_per_unit=memory_per_unit,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- num_of_units: Optional[int] = None,
- cpu_per_unit: Optional[int] = None,
- gpu_per_unit: Optional[int] = None,
- memory_per_unit: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if num_of_units is None and 'numOfUnits' in kwargs:
- num_of_units = kwargs['numOfUnits']
- if num_of_units is None:
- raise TypeError("Missing 'num_of_units' argument")
- if cpu_per_unit is None and 'cpuPerUnit' in kwargs:
- cpu_per_unit = kwargs['cpuPerUnit']
- if gpu_per_unit is None and 'gpuPerUnit' in kwargs:
- gpu_per_unit = kwargs['gpuPerUnit']
- if memory_per_unit is None and 'memoryPerUnit' in kwargs:
- memory_per_unit = kwargs['memoryPerUnit']
-
- _setter("num_of_units", num_of_units)
+ pulumi.set(__self__, "num_of_units", num_of_units)
if cpu_per_unit is not None:
- _setter("cpu_per_unit", cpu_per_unit)
+ pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
if gpu_per_unit is not None:
- _setter("gpu_per_unit", gpu_per_unit)
+ pulumi.set(__self__, "gpu_per_unit", gpu_per_unit)
if memory_per_unit is not None:
- _setter("memory_per_unit", memory_per_unit)
+ pulumi.set(__self__, "memory_per_unit", memory_per_unit)
@property
@pulumi.getter(name="numOfUnits")
@@ -3579,27 +2578,10 @@ def __init__(__self__, *,
:param bool enable_integrity_monitoring: Boolean. Enable the integrity monitoring parameter on the GCP instances.
:param bool enable_secure_boot: Boolean. Enable the secure boot parameter on the GCP instances.
"""
- OceanLaunchSpecShieldedInstanceConfig._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- enable_integrity_monitoring=enable_integrity_monitoring,
- enable_secure_boot=enable_secure_boot,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- enable_integrity_monitoring: Optional[bool] = None,
- enable_secure_boot: Optional[bool] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if enable_integrity_monitoring is None and 'enableIntegrityMonitoring' in kwargs:
- enable_integrity_monitoring = kwargs['enableIntegrityMonitoring']
- if enable_secure_boot is None and 'enableSecureBoot' in kwargs:
- enable_secure_boot = kwargs['enableSecureBoot']
-
if enable_integrity_monitoring is not None:
- _setter("enable_integrity_monitoring", enable_integrity_monitoring)
+ pulumi.set(__self__, "enable_integrity_monitoring", enable_integrity_monitoring)
if enable_secure_boot is not None:
- _setter("enable_secure_boot", enable_secure_boot)
+ pulumi.set(__self__, "enable_secure_boot", enable_secure_boot)
@property
@pulumi.getter(name="enableIntegrityMonitoring")
@@ -3642,21 +2624,8 @@ def __init__(__self__, *,
"""
:param int local_ssd_count: Defines the number of local SSDs to be attached per node for this VNG.
"""
- OceanLaunchSpecStorage._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- local_ssd_count=local_ssd_count,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- local_ssd_count: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if local_ssd_count is None and 'localSsdCount' in kwargs:
- local_ssd_count = kwargs['localSsdCount']
-
if local_ssd_count is not None:
- _setter("local_ssd_count", local_ssd_count)
+ pulumi.set(__self__, "local_ssd_count", local_ssd_count)
@property
@pulumi.getter(name="localSsdCount")
@@ -3691,21 +2660,8 @@ def __init__(__self__, *,
"""
:param int preemptible_percentage: Defines the desired preemptible percentage for this launch specification.
"""
- OceanLaunchSpecStrategy._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- preemptible_percentage=preemptible_percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- preemptible_percentage: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if preemptible_percentage is None and 'preemptiblePercentage' in kwargs:
- preemptible_percentage = kwargs['preemptiblePercentage']
-
if preemptible_percentage is not None:
- _setter("preemptible_percentage", preemptible_percentage)
+ pulumi.set(__self__, "preemptible_percentage", preemptible_percentage)
@property
@pulumi.getter(name="preemptiblePercentage")
@@ -3727,27 +2683,12 @@ def __init__(__self__, *,
:param str key: The label key.
:param str value: The label value.
"""
- OceanLaunchSpecTaint._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- effect=effect,
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- effect: Optional[str] = None,
- key: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if effect is not None:
- _setter("effect", effect)
+ pulumi.set(__self__, "effect", effect)
if key is not None:
- _setter("key", key)
+ pulumi.set(__self__, "key", key)
if value is not None:
- _setter("value", value)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -3798,28 +2739,9 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
should_roll: bool,
roll_config: Optional['outputs.OceanLaunchSpecUpdatePolicyRollConfig'] = None):
- OceanLaunchSpecUpdatePolicy._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- should_roll=should_roll,
- roll_config=roll_config,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- should_roll: Optional[bool] = None,
- roll_config: Optional['outputs.OceanLaunchSpecUpdatePolicyRollConfig'] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if should_roll is None and 'shouldRoll' in kwargs:
- should_roll = kwargs['shouldRoll']
- if should_roll is None:
- raise TypeError("Missing 'should_roll' argument")
- if roll_config is None and 'rollConfig' in kwargs:
- roll_config = kwargs['rollConfig']
-
- _setter("should_roll", should_roll)
+ pulumi.set(__self__, "should_roll", should_roll)
if roll_config is not None:
- _setter("roll_config", roll_config)
+ pulumi.set(__self__, "roll_config", roll_config)
@property
@pulumi.getter(name="shouldRoll")
@@ -3853,22 +2775,7 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
batch_size_percentage: int):
- OceanLaunchSpecUpdatePolicyRollConfig._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- batch_size_percentage=batch_size_percentage,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- batch_size_percentage: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if batch_size_percentage is None and 'batchSizePercentage' in kwargs:
- batch_size_percentage = kwargs['batchSizePercentage']
- if batch_size_percentage is None:
- raise TypeError("Missing 'batch_size_percentage' argument")
-
- _setter("batch_size_percentage", batch_size_percentage)
+ pulumi.set(__self__, "batch_size_percentage", batch_size_percentage)
@property
@pulumi.getter(name="batchSizePercentage")
diff --git a/sdk/python/pulumi_spotinst/health_check.py b/sdk/python/pulumi_spotinst/health_check.py
index a4321c12..a54adfb1 100644
--- a/sdk/python/pulumi_spotinst/health_check.py
+++ b/sdk/python/pulumi_spotinst/health_check.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from . import _utilities
from . import outputs
from ._inputs import *
@@ -27,43 +27,14 @@ def __init__(__self__, *,
:param pulumi.Input['HealthCheckCheckArgs'] check: Describes the check to execute.
:param pulumi.Input[str] name: The name of the health check.
"""
- HealthCheckArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- proxy_address=proxy_address,
- resource_id=resource_id,
- check=check,
- name=name,
- proxy_port=proxy_port,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- proxy_address: Optional[pulumi.Input[str]] = None,
- resource_id: Optional[pulumi.Input[str]] = None,
- check: Optional[pulumi.Input['HealthCheckCheckArgs']] = None,
- name: Optional[pulumi.Input[str]] = None,
- proxy_port: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if proxy_address is None and 'proxyAddress' in kwargs:
- proxy_address = kwargs['proxyAddress']
- if proxy_address is None:
- raise TypeError("Missing 'proxy_address' argument")
- if resource_id is None and 'resourceId' in kwargs:
- resource_id = kwargs['resourceId']
- if resource_id is None:
- raise TypeError("Missing 'resource_id' argument")
- if proxy_port is None and 'proxyPort' in kwargs:
- proxy_port = kwargs['proxyPort']
-
- _setter("proxy_address", proxy_address)
- _setter("resource_id", resource_id)
+ pulumi.set(__self__, "proxy_address", proxy_address)
+ pulumi.set(__self__, "resource_id", resource_id)
if check is not None:
- _setter("check", check)
+ pulumi.set(__self__, "check", check)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if proxy_port is not None:
- _setter("proxy_port", proxy_port)
+ pulumi.set(__self__, "proxy_port", proxy_port)
@property
@pulumi.getter(name="proxyAddress")
@@ -134,41 +105,16 @@ def __init__(__self__, *,
:param pulumi.Input[str] name: The name of the health check.
:param pulumi.Input[str] resource_id: The ID of the resource to check.
"""
- _HealthCheckState._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- check=check,
- name=name,
- proxy_address=proxy_address,
- proxy_port=proxy_port,
- resource_id=resource_id,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- check: Optional[pulumi.Input['HealthCheckCheckArgs']] = None,
- name: Optional[pulumi.Input[str]] = None,
- proxy_address: Optional[pulumi.Input[str]] = None,
- proxy_port: Optional[pulumi.Input[int]] = None,
- resource_id: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if proxy_address is None and 'proxyAddress' in kwargs:
- proxy_address = kwargs['proxyAddress']
- if proxy_port is None and 'proxyPort' in kwargs:
- proxy_port = kwargs['proxyPort']
- if resource_id is None and 'resourceId' in kwargs:
- resource_id = kwargs['resourceId']
-
if check is not None:
- _setter("check", check)
+ pulumi.set(__self__, "check", check)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if proxy_address is not None:
- _setter("proxy_address", proxy_address)
+ pulumi.set(__self__, "proxy_address", proxy_address)
if proxy_port is not None:
- _setter("proxy_port", proxy_port)
+ pulumi.set(__self__, "proxy_port", proxy_port)
if resource_id is not None:
- _setter("resource_id", resource_id)
+ pulumi.set(__self__, "resource_id", resource_id)
@property
@pulumi.getter
@@ -306,10 +252,6 @@ def __init__(__self__, resource_name: str, *args, **kwargs):
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
- kwargs = kwargs or {}
- def _setter(key, value):
- kwargs[key] = value
- HealthCheckArgs._configure(_setter, **kwargs)
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
@@ -329,7 +271,6 @@ def _internal_init(__self__,
raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
__props__ = HealthCheckArgs.__new__(HealthCheckArgs)
- check = _utilities.configure(check, HealthCheckCheckArgs, True)
__props__.__dict__["check"] = check
__props__.__dict__["name"] = name
if proxy_address is None and not opts.urn:
diff --git a/sdk/python/pulumi_spotinst/multai/_inputs.py b/sdk/python/pulumi_spotinst/multai/_inputs.py
index 09659479..4d2b1c40 100644
--- a/sdk/python/pulumi_spotinst/multai/_inputs.py
+++ b/sdk/python/pulumi_spotinst/multai/_inputs.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
__all__ = [
@@ -25,23 +25,10 @@ class BalancerConnectionTimeoutsArgs:
def __init__(__self__, *,
draining: Optional[pulumi.Input[int]] = None,
idle: Optional[pulumi.Input[int]] = None):
- BalancerConnectionTimeoutsArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- draining=draining,
- idle=idle,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- draining: Optional[pulumi.Input[int]] = None,
- idle: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if draining is not None:
- _setter("draining", draining)
+ pulumi.set(__self__, "draining", draining)
if idle is not None:
- _setter("idle", idle)
+ pulumi.set(__self__, "idle", idle)
@property
@pulumi.getter
@@ -67,25 +54,8 @@ class BalancerTagArgs:
def __init__(__self__, *,
key: pulumi.Input[str],
value: pulumi.Input[str]):
- BalancerTagArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -111,25 +81,8 @@ class ListenerTagArgs:
def __init__(__self__, *,
key: pulumi.Input[str],
value: pulumi.Input[str]):
- ListenerTagArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -159,57 +112,12 @@ def __init__(__self__, *,
min_version: pulumi.Input[str],
prefer_server_cipher_suites: pulumi.Input[bool],
session_tickets_disabled: pulumi.Input[bool]):
- ListenerTlsConfigArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- certificate_ids=certificate_ids,
- cipher_suites=cipher_suites,
- max_version=max_version,
- min_version=min_version,
- prefer_server_cipher_suites=prefer_server_cipher_suites,
- session_tickets_disabled=session_tickets_disabled,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- certificate_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- cipher_suites: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- max_version: Optional[pulumi.Input[str]] = None,
- min_version: Optional[pulumi.Input[str]] = None,
- prefer_server_cipher_suites: Optional[pulumi.Input[bool]] = None,
- session_tickets_disabled: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if certificate_ids is None and 'certificateIds' in kwargs:
- certificate_ids = kwargs['certificateIds']
- if certificate_ids is None:
- raise TypeError("Missing 'certificate_ids' argument")
- if cipher_suites is None and 'cipherSuites' in kwargs:
- cipher_suites = kwargs['cipherSuites']
- if cipher_suites is None:
- raise TypeError("Missing 'cipher_suites' argument")
- if max_version is None and 'maxVersion' in kwargs:
- max_version = kwargs['maxVersion']
- if max_version is None:
- raise TypeError("Missing 'max_version' argument")
- if min_version is None and 'minVersion' in kwargs:
- min_version = kwargs['minVersion']
- if min_version is None:
- raise TypeError("Missing 'min_version' argument")
- if prefer_server_cipher_suites is None and 'preferServerCipherSuites' in kwargs:
- prefer_server_cipher_suites = kwargs['preferServerCipherSuites']
- if prefer_server_cipher_suites is None:
- raise TypeError("Missing 'prefer_server_cipher_suites' argument")
- if session_tickets_disabled is None and 'sessionTicketsDisabled' in kwargs:
- session_tickets_disabled = kwargs['sessionTicketsDisabled']
- if session_tickets_disabled is None:
- raise TypeError("Missing 'session_tickets_disabled' argument")
-
- _setter("certificate_ids", certificate_ids)
- _setter("cipher_suites", cipher_suites)
- _setter("max_version", max_version)
- _setter("min_version", min_version)
- _setter("prefer_server_cipher_suites", prefer_server_cipher_suites)
- _setter("session_tickets_disabled", session_tickets_disabled)
+ pulumi.set(__self__, "certificate_ids", certificate_ids)
+ pulumi.set(__self__, "cipher_suites", cipher_suites)
+ pulumi.set(__self__, "max_version", max_version)
+ pulumi.set(__self__, "min_version", min_version)
+ pulumi.set(__self__, "prefer_server_cipher_suites", prefer_server_cipher_suites)
+ pulumi.set(__self__, "session_tickets_disabled", session_tickets_disabled)
@property
@pulumi.getter(name="certificateIds")
@@ -271,25 +179,8 @@ class RoutingRuleTagArgs:
def __init__(__self__, *,
key: pulumi.Input[str],
value: pulumi.Input[str]):
- RoutingRuleTagArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -320,53 +211,14 @@ def __init__(__self__, *,
timeout: pulumi.Input[int],
unhealthy_threshold: pulumi.Input[int],
port: Optional[pulumi.Input[int]] = None):
- TargetSetHealthCheckArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- healthy_threshold=healthy_threshold,
- interval=interval,
- path=path,
- protocol=protocol,
- timeout=timeout,
- unhealthy_threshold=unhealthy_threshold,
- port=port,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- healthy_threshold: Optional[pulumi.Input[int]] = None,
- interval: Optional[pulumi.Input[int]] = None,
- path: Optional[pulumi.Input[str]] = None,
- protocol: Optional[pulumi.Input[str]] = None,
- timeout: Optional[pulumi.Input[int]] = None,
- unhealthy_threshold: Optional[pulumi.Input[int]] = None,
- port: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if healthy_threshold is None and 'healthyThreshold' in kwargs:
- healthy_threshold = kwargs['healthyThreshold']
- if healthy_threshold is None:
- raise TypeError("Missing 'healthy_threshold' argument")
- if interval is None:
- raise TypeError("Missing 'interval' argument")
- if path is None:
- raise TypeError("Missing 'path' argument")
- if protocol is None:
- raise TypeError("Missing 'protocol' argument")
- if timeout is None:
- raise TypeError("Missing 'timeout' argument")
- if unhealthy_threshold is None and 'unhealthyThreshold' in kwargs:
- unhealthy_threshold = kwargs['unhealthyThreshold']
- if unhealthy_threshold is None:
- raise TypeError("Missing 'unhealthy_threshold' argument")
-
- _setter("healthy_threshold", healthy_threshold)
- _setter("interval", interval)
- _setter("path", path)
- _setter("protocol", protocol)
- _setter("timeout", timeout)
- _setter("unhealthy_threshold", unhealthy_threshold)
+ pulumi.set(__self__, "healthy_threshold", healthy_threshold)
+ pulumi.set(__self__, "interval", interval)
+ pulumi.set(__self__, "path", path)
+ pulumi.set(__self__, "protocol", protocol)
+ pulumi.set(__self__, "timeout", timeout)
+ pulumi.set(__self__, "unhealthy_threshold", unhealthy_threshold)
if port is not None:
- _setter("port", port)
+ pulumi.set(__self__, "port", port)
@property
@pulumi.getter(name="healthyThreshold")
@@ -437,25 +289,8 @@ class TargetSetTagArgs:
def __init__(__self__, *,
key: pulumi.Input[str],
value: pulumi.Input[str]):
- TargetSetTagArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -481,25 +316,8 @@ class TargetTagArgs:
def __init__(__self__, *,
key: pulumi.Input[str],
value: pulumi.Input[str]):
- TargetTagArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[pulumi.Input[str]] = None,
- value: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
diff --git a/sdk/python/pulumi_spotinst/multai/balancer.py b/sdk/python/pulumi_spotinst/multai/balancer.py
index 0d6c009c..230acd86 100644
--- a/sdk/python/pulumi_spotinst/multai/balancer.py
+++ b/sdk/python/pulumi_spotinst/multai/balancer.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs
from ._inputs import *
@@ -24,39 +24,16 @@ def __init__(__self__, *,
"""
The set of arguments for constructing a Balancer resource.
"""
- BalancerArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- connection_timeouts=connection_timeouts,
- dns_cname_aliases=dns_cname_aliases,
- name=name,
- scheme=scheme,
- tags=tags,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- connection_timeouts: Optional[pulumi.Input['BalancerConnectionTimeoutsArgs']] = None,
- dns_cname_aliases: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- name: Optional[pulumi.Input[str]] = None,
- scheme: Optional[pulumi.Input[str]] = None,
- tags: Optional[pulumi.Input[Sequence[pulumi.Input['BalancerTagArgs']]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if connection_timeouts is None and 'connectionTimeouts' in kwargs:
- connection_timeouts = kwargs['connectionTimeouts']
- if dns_cname_aliases is None and 'dnsCnameAliases' in kwargs:
- dns_cname_aliases = kwargs['dnsCnameAliases']
-
if connection_timeouts is not None:
- _setter("connection_timeouts", connection_timeouts)
+ pulumi.set(__self__, "connection_timeouts", connection_timeouts)
if dns_cname_aliases is not None:
- _setter("dns_cname_aliases", dns_cname_aliases)
+ pulumi.set(__self__, "dns_cname_aliases", dns_cname_aliases)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if scheme is not None:
- _setter("scheme", scheme)
+ pulumi.set(__self__, "scheme", scheme)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
@property
@pulumi.getter(name="connectionTimeouts")
@@ -115,39 +92,16 @@ def __init__(__self__, *,
"""
Input properties used for looking up and filtering Balancer resources.
"""
- _BalancerState._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- connection_timeouts=connection_timeouts,
- dns_cname_aliases=dns_cname_aliases,
- name=name,
- scheme=scheme,
- tags=tags,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- connection_timeouts: Optional[pulumi.Input['BalancerConnectionTimeoutsArgs']] = None,
- dns_cname_aliases: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- name: Optional[pulumi.Input[str]] = None,
- scheme: Optional[pulumi.Input[str]] = None,
- tags: Optional[pulumi.Input[Sequence[pulumi.Input['BalancerTagArgs']]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if connection_timeouts is None and 'connectionTimeouts' in kwargs:
- connection_timeouts = kwargs['connectionTimeouts']
- if dns_cname_aliases is None and 'dnsCnameAliases' in kwargs:
- dns_cname_aliases = kwargs['dnsCnameAliases']
-
if connection_timeouts is not None:
- _setter("connection_timeouts", connection_timeouts)
+ pulumi.set(__self__, "connection_timeouts", connection_timeouts)
if dns_cname_aliases is not None:
- _setter("dns_cname_aliases", dns_cname_aliases)
+ pulumi.set(__self__, "dns_cname_aliases", dns_cname_aliases)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if scheme is not None:
- _setter("scheme", scheme)
+ pulumi.set(__self__, "scheme", scheme)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
@property
@pulumi.getter(name="connectionTimeouts")
@@ -229,10 +183,6 @@ def __init__(__self__, resource_name: str, *args, **kwargs):
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
- kwargs = kwargs or {}
- def _setter(key, value):
- kwargs[key] = value
- BalancerArgs._configure(_setter, **kwargs)
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
@@ -252,7 +202,6 @@ def _internal_init(__self__,
raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
__props__ = BalancerArgs.__new__(BalancerArgs)
- connection_timeouts = _utilities.configure(connection_timeouts, BalancerConnectionTimeoutsArgs, True)
__props__.__dict__["connection_timeouts"] = connection_timeouts
__props__.__dict__["dns_cname_aliases"] = dns_cname_aliases
__props__.__dict__["name"] = name
diff --git a/sdk/python/pulumi_spotinst/multai/deployment.py b/sdk/python/pulumi_spotinst/multai/deployment.py
index c928ff46..92e07b34 100644
--- a/sdk/python/pulumi_spotinst/multai/deployment.py
+++ b/sdk/python/pulumi_spotinst/multai/deployment.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
__all__ = ['DeploymentArgs', 'Deployment']
@@ -18,19 +18,8 @@ def __init__(__self__, *,
"""
The set of arguments for constructing a Deployment resource.
"""
- DeploymentArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
@property
@pulumi.getter
@@ -49,19 +38,8 @@ def __init__(__self__, *,
"""
Input properties used for looking up and filtering Deployment resources.
"""
- _DeploymentState._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
@property
@pulumi.getter
@@ -103,10 +81,6 @@ def __init__(__self__, resource_name: str, *args, **kwargs):
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
- kwargs = kwargs or {}
- def _setter(key, value):
- kwargs[key] = value
- DeploymentArgs._configure(_setter, **kwargs)
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
diff --git a/sdk/python/pulumi_spotinst/multai/listener.py b/sdk/python/pulumi_spotinst/multai/listener.py
index 9a02fae2..824a2880 100644
--- a/sdk/python/pulumi_spotinst/multai/listener.py
+++ b/sdk/python/pulumi_spotinst/multai/listener.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs
from ._inputs import *
@@ -24,42 +24,13 @@ def __init__(__self__, *,
"""
The set of arguments for constructing a Listener resource.
"""
- ListenerArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- balancer_id=balancer_id,
- port=port,
- protocol=protocol,
- tags=tags,
- tls_config=tls_config,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- balancer_id: Optional[pulumi.Input[str]] = None,
- port: Optional[pulumi.Input[int]] = None,
- protocol: Optional[pulumi.Input[str]] = None,
- tags: Optional[pulumi.Input[Sequence[pulumi.Input['ListenerTagArgs']]]] = None,
- tls_config: Optional[pulumi.Input['ListenerTlsConfigArgs']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if balancer_id is None and 'balancerId' in kwargs:
- balancer_id = kwargs['balancerId']
- if balancer_id is None:
- raise TypeError("Missing 'balancer_id' argument")
- if port is None:
- raise TypeError("Missing 'port' argument")
- if protocol is None:
- raise TypeError("Missing 'protocol' argument")
- if tls_config is None and 'tlsConfig' in kwargs:
- tls_config = kwargs['tlsConfig']
-
- _setter("balancer_id", balancer_id)
- _setter("port", port)
- _setter("protocol", protocol)
+ pulumi.set(__self__, "balancer_id", balancer_id)
+ pulumi.set(__self__, "port", port)
+ pulumi.set(__self__, "protocol", protocol)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
if tls_config is not None:
- _setter("tls_config", tls_config)
+ pulumi.set(__self__, "tls_config", tls_config)
@property
@pulumi.getter(name="balancerId")
@@ -118,39 +89,16 @@ def __init__(__self__, *,
"""
Input properties used for looking up and filtering Listener resources.
"""
- _ListenerState._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- balancer_id=balancer_id,
- port=port,
- protocol=protocol,
- tags=tags,
- tls_config=tls_config,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- balancer_id: Optional[pulumi.Input[str]] = None,
- port: Optional[pulumi.Input[int]] = None,
- protocol: Optional[pulumi.Input[str]] = None,
- tags: Optional[pulumi.Input[Sequence[pulumi.Input['ListenerTagArgs']]]] = None,
- tls_config: Optional[pulumi.Input['ListenerTlsConfigArgs']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if balancer_id is None and 'balancerId' in kwargs:
- balancer_id = kwargs['balancerId']
- if tls_config is None and 'tlsConfig' in kwargs:
- tls_config = kwargs['tlsConfig']
-
if balancer_id is not None:
- _setter("balancer_id", balancer_id)
+ pulumi.set(__self__, "balancer_id", balancer_id)
if port is not None:
- _setter("port", port)
+ pulumi.set(__self__, "port", port)
if protocol is not None:
- _setter("protocol", protocol)
+ pulumi.set(__self__, "protocol", protocol)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
if tls_config is not None:
- _setter("tls_config", tls_config)
+ pulumi.set(__self__, "tls_config", tls_config)
@property
@pulumi.getter(name="balancerId")
@@ -232,10 +180,6 @@ def __init__(__self__, resource_name: str, *args, **kwargs):
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
- kwargs = kwargs or {}
- def _setter(key, value):
- kwargs[key] = value
- ListenerArgs._configure(_setter, **kwargs)
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
@@ -265,7 +209,6 @@ def _internal_init(__self__,
raise TypeError("Missing required property 'protocol'")
__props__.__dict__["protocol"] = protocol
__props__.__dict__["tags"] = tags
- tls_config = _utilities.configure(tls_config, ListenerTlsConfigArgs, True)
__props__.__dict__["tls_config"] = tls_config
super(Listener, __self__).__init__(
'spotinst:multai/listener:Listener',
diff --git a/sdk/python/pulumi_spotinst/multai/outputs.py b/sdk/python/pulumi_spotinst/multai/outputs.py
index 4bafbe6e..0c5d8d21 100644
--- a/sdk/python/pulumi_spotinst/multai/outputs.py
+++ b/sdk/python/pulumi_spotinst/multai/outputs.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
__all__ = [
@@ -25,23 +25,10 @@ class BalancerConnectionTimeouts(dict):
def __init__(__self__, *,
draining: Optional[int] = None,
idle: Optional[int] = None):
- BalancerConnectionTimeouts._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- draining=draining,
- idle=idle,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- draining: Optional[int] = None,
- idle: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if draining is not None:
- _setter("draining", draining)
+ pulumi.set(__self__, "draining", draining)
if idle is not None:
- _setter("idle", idle)
+ pulumi.set(__self__, "idle", idle)
@property
@pulumi.getter
@@ -59,25 +46,8 @@ class BalancerTag(dict):
def __init__(__self__, *,
key: str,
value: str):
- BalancerTag._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -95,25 +65,8 @@ class ListenerTag(dict):
def __init__(__self__, *,
key: str,
value: str):
- ListenerTag._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -162,57 +115,12 @@ def __init__(__self__, *,
min_version: str,
prefer_server_cipher_suites: bool,
session_tickets_disabled: bool):
- ListenerTlsConfig._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- certificate_ids=certificate_ids,
- cipher_suites=cipher_suites,
- max_version=max_version,
- min_version=min_version,
- prefer_server_cipher_suites=prefer_server_cipher_suites,
- session_tickets_disabled=session_tickets_disabled,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- certificate_ids: Optional[Sequence[str]] = None,
- cipher_suites: Optional[Sequence[str]] = None,
- max_version: Optional[str] = None,
- min_version: Optional[str] = None,
- prefer_server_cipher_suites: Optional[bool] = None,
- session_tickets_disabled: Optional[bool] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if certificate_ids is None and 'certificateIds' in kwargs:
- certificate_ids = kwargs['certificateIds']
- if certificate_ids is None:
- raise TypeError("Missing 'certificate_ids' argument")
- if cipher_suites is None and 'cipherSuites' in kwargs:
- cipher_suites = kwargs['cipherSuites']
- if cipher_suites is None:
- raise TypeError("Missing 'cipher_suites' argument")
- if max_version is None and 'maxVersion' in kwargs:
- max_version = kwargs['maxVersion']
- if max_version is None:
- raise TypeError("Missing 'max_version' argument")
- if min_version is None and 'minVersion' in kwargs:
- min_version = kwargs['minVersion']
- if min_version is None:
- raise TypeError("Missing 'min_version' argument")
- if prefer_server_cipher_suites is None and 'preferServerCipherSuites' in kwargs:
- prefer_server_cipher_suites = kwargs['preferServerCipherSuites']
- if prefer_server_cipher_suites is None:
- raise TypeError("Missing 'prefer_server_cipher_suites' argument")
- if session_tickets_disabled is None and 'sessionTicketsDisabled' in kwargs:
- session_tickets_disabled = kwargs['sessionTicketsDisabled']
- if session_tickets_disabled is None:
- raise TypeError("Missing 'session_tickets_disabled' argument")
-
- _setter("certificate_ids", certificate_ids)
- _setter("cipher_suites", cipher_suites)
- _setter("max_version", max_version)
- _setter("min_version", min_version)
- _setter("prefer_server_cipher_suites", prefer_server_cipher_suites)
- _setter("session_tickets_disabled", session_tickets_disabled)
+ pulumi.set(__self__, "certificate_ids", certificate_ids)
+ pulumi.set(__self__, "cipher_suites", cipher_suites)
+ pulumi.set(__self__, "max_version", max_version)
+ pulumi.set(__self__, "min_version", min_version)
+ pulumi.set(__self__, "prefer_server_cipher_suites", prefer_server_cipher_suites)
+ pulumi.set(__self__, "session_tickets_disabled", session_tickets_disabled)
@property
@pulumi.getter(name="certificateIds")
@@ -250,25 +158,8 @@ class RoutingRuleTag(dict):
def __init__(__self__, *,
key: str,
value: str):
- RoutingRuleTag._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -310,53 +201,14 @@ def __init__(__self__, *,
timeout: int,
unhealthy_threshold: int,
port: Optional[int] = None):
- TargetSetHealthCheck._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- healthy_threshold=healthy_threshold,
- interval=interval,
- path=path,
- protocol=protocol,
- timeout=timeout,
- unhealthy_threshold=unhealthy_threshold,
- port=port,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- healthy_threshold: Optional[int] = None,
- interval: Optional[int] = None,
- path: Optional[str] = None,
- protocol: Optional[str] = None,
- timeout: Optional[int] = None,
- unhealthy_threshold: Optional[int] = None,
- port: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if healthy_threshold is None and 'healthyThreshold' in kwargs:
- healthy_threshold = kwargs['healthyThreshold']
- if healthy_threshold is None:
- raise TypeError("Missing 'healthy_threshold' argument")
- if interval is None:
- raise TypeError("Missing 'interval' argument")
- if path is None:
- raise TypeError("Missing 'path' argument")
- if protocol is None:
- raise TypeError("Missing 'protocol' argument")
- if timeout is None:
- raise TypeError("Missing 'timeout' argument")
- if unhealthy_threshold is None and 'unhealthyThreshold' in kwargs:
- unhealthy_threshold = kwargs['unhealthyThreshold']
- if unhealthy_threshold is None:
- raise TypeError("Missing 'unhealthy_threshold' argument")
-
- _setter("healthy_threshold", healthy_threshold)
- _setter("interval", interval)
- _setter("path", path)
- _setter("protocol", protocol)
- _setter("timeout", timeout)
- _setter("unhealthy_threshold", unhealthy_threshold)
+ pulumi.set(__self__, "healthy_threshold", healthy_threshold)
+ pulumi.set(__self__, "interval", interval)
+ pulumi.set(__self__, "path", path)
+ pulumi.set(__self__, "protocol", protocol)
+ pulumi.set(__self__, "timeout", timeout)
+ pulumi.set(__self__, "unhealthy_threshold", unhealthy_threshold)
if port is not None:
- _setter("port", port)
+ pulumi.set(__self__, "port", port)
@property
@pulumi.getter(name="healthyThreshold")
@@ -399,25 +251,8 @@ class TargetSetTag(dict):
def __init__(__self__, *,
key: str,
value: str):
- TargetSetTag._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -435,25 +270,8 @@ class TargetTag(dict):
def __init__(__self__, *,
key: str,
value: str):
- TargetTag._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
diff --git a/sdk/python/pulumi_spotinst/multai/routing_rule.py b/sdk/python/pulumi_spotinst/multai/routing_rule.py
index 4a1733f0..a8fd30e6 100644
--- a/sdk/python/pulumi_spotinst/multai/routing_rule.py
+++ b/sdk/python/pulumi_spotinst/multai/routing_rule.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs
from ._inputs import *
@@ -27,59 +27,18 @@ def __init__(__self__, *,
"""
The set of arguments for constructing a RoutingRule resource.
"""
- RoutingRuleArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- balancer_id=balancer_id,
- listener_id=listener_id,
- route=route,
- target_set_ids=target_set_ids,
- middleware_ids=middleware_ids,
- priority=priority,
- strategy=strategy,
- tags=tags,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- balancer_id: Optional[pulumi.Input[str]] = None,
- listener_id: Optional[pulumi.Input[str]] = None,
- route: Optional[pulumi.Input[str]] = None,
- target_set_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- middleware_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- priority: Optional[pulumi.Input[int]] = None,
- strategy: Optional[pulumi.Input[str]] = None,
- tags: Optional[pulumi.Input[Sequence[pulumi.Input['RoutingRuleTagArgs']]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if balancer_id is None and 'balancerId' in kwargs:
- balancer_id = kwargs['balancerId']
- if balancer_id is None:
- raise TypeError("Missing 'balancer_id' argument")
- if listener_id is None and 'listenerId' in kwargs:
- listener_id = kwargs['listenerId']
- if listener_id is None:
- raise TypeError("Missing 'listener_id' argument")
- if route is None:
- raise TypeError("Missing 'route' argument")
- if target_set_ids is None and 'targetSetIds' in kwargs:
- target_set_ids = kwargs['targetSetIds']
- if target_set_ids is None:
- raise TypeError("Missing 'target_set_ids' argument")
- if middleware_ids is None and 'middlewareIds' in kwargs:
- middleware_ids = kwargs['middlewareIds']
-
- _setter("balancer_id", balancer_id)
- _setter("listener_id", listener_id)
- _setter("route", route)
- _setter("target_set_ids", target_set_ids)
+ pulumi.set(__self__, "balancer_id", balancer_id)
+ pulumi.set(__self__, "listener_id", listener_id)
+ pulumi.set(__self__, "route", route)
+ pulumi.set(__self__, "target_set_ids", target_set_ids)
if middleware_ids is not None:
- _setter("middleware_ids", middleware_ids)
+ pulumi.set(__self__, "middleware_ids", middleware_ids)
if priority is not None:
- _setter("priority", priority)
+ pulumi.set(__self__, "priority", priority)
if strategy is not None:
- _setter("strategy", strategy)
+ pulumi.set(__self__, "strategy", strategy)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
@property
@pulumi.getter(name="balancerId")
@@ -168,55 +127,22 @@ def __init__(__self__, *,
"""
Input properties used for looking up and filtering RoutingRule resources.
"""
- _RoutingRuleState._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- balancer_id=balancer_id,
- listener_id=listener_id,
- middleware_ids=middleware_ids,
- priority=priority,
- route=route,
- strategy=strategy,
- tags=tags,
- target_set_ids=target_set_ids,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- balancer_id: Optional[pulumi.Input[str]] = None,
- listener_id: Optional[pulumi.Input[str]] = None,
- middleware_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- priority: Optional[pulumi.Input[int]] = None,
- route: Optional[pulumi.Input[str]] = None,
- strategy: Optional[pulumi.Input[str]] = None,
- tags: Optional[pulumi.Input[Sequence[pulumi.Input['RoutingRuleTagArgs']]]] = None,
- target_set_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if balancer_id is None and 'balancerId' in kwargs:
- balancer_id = kwargs['balancerId']
- if listener_id is None and 'listenerId' in kwargs:
- listener_id = kwargs['listenerId']
- if middleware_ids is None and 'middlewareIds' in kwargs:
- middleware_ids = kwargs['middlewareIds']
- if target_set_ids is None and 'targetSetIds' in kwargs:
- target_set_ids = kwargs['targetSetIds']
-
if balancer_id is not None:
- _setter("balancer_id", balancer_id)
+ pulumi.set(__self__, "balancer_id", balancer_id)
if listener_id is not None:
- _setter("listener_id", listener_id)
+ pulumi.set(__self__, "listener_id", listener_id)
if middleware_ids is not None:
- _setter("middleware_ids", middleware_ids)
+ pulumi.set(__self__, "middleware_ids", middleware_ids)
if priority is not None:
- _setter("priority", priority)
+ pulumi.set(__self__, "priority", priority)
if route is not None:
- _setter("route", route)
+ pulumi.set(__self__, "route", route)
if strategy is not None:
- _setter("strategy", strategy)
+ pulumi.set(__self__, "strategy", strategy)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
if target_set_ids is not None:
- _setter("target_set_ids", target_set_ids)
+ pulumi.set(__self__, "target_set_ids", target_set_ids)
@property
@pulumi.getter(name="balancerId")
@@ -328,10 +254,6 @@ def __init__(__self__, resource_name: str, *args, **kwargs):
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
- kwargs = kwargs or {}
- def _setter(key, value):
- kwargs[key] = value
- RoutingRuleArgs._configure(_setter, **kwargs)
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
diff --git a/sdk/python/pulumi_spotinst/multai/target.py b/sdk/python/pulumi_spotinst/multai/target.py
index 52951b59..02c9180c 100644
--- a/sdk/python/pulumi_spotinst/multai/target.py
+++ b/sdk/python/pulumi_spotinst/multai/target.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs
from ._inputs import *
@@ -26,51 +26,16 @@ def __init__(__self__, *,
"""
The set of arguments for constructing a Target resource.
"""
- TargetArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- balancer_id=balancer_id,
- host=host,
- target_set_id=target_set_id,
- weight=weight,
- name=name,
- port=port,
- tags=tags,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- balancer_id: Optional[pulumi.Input[str]] = None,
- host: Optional[pulumi.Input[str]] = None,
- target_set_id: Optional[pulumi.Input[str]] = None,
- weight: Optional[pulumi.Input[int]] = None,
- name: Optional[pulumi.Input[str]] = None,
- port: Optional[pulumi.Input[int]] = None,
- tags: Optional[pulumi.Input[Sequence[pulumi.Input['TargetTagArgs']]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if balancer_id is None and 'balancerId' in kwargs:
- balancer_id = kwargs['balancerId']
- if balancer_id is None:
- raise TypeError("Missing 'balancer_id' argument")
- if host is None:
- raise TypeError("Missing 'host' argument")
- if target_set_id is None and 'targetSetId' in kwargs:
- target_set_id = kwargs['targetSetId']
- if target_set_id is None:
- raise TypeError("Missing 'target_set_id' argument")
- if weight is None:
- raise TypeError("Missing 'weight' argument")
-
- _setter("balancer_id", balancer_id)
- _setter("host", host)
- _setter("target_set_id", target_set_id)
- _setter("weight", weight)
+ pulumi.set(__self__, "balancer_id", balancer_id)
+ pulumi.set(__self__, "host", host)
+ pulumi.set(__self__, "target_set_id", target_set_id)
+ pulumi.set(__self__, "weight", weight)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if port is not None:
- _setter("port", port)
+ pulumi.set(__self__, "port", port)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
@property
@pulumi.getter(name="balancerId")
@@ -149,47 +114,20 @@ def __init__(__self__, *,
"""
Input properties used for looking up and filtering Target resources.
"""
- _TargetState._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- balancer_id=balancer_id,
- host=host,
- name=name,
- port=port,
- tags=tags,
- target_set_id=target_set_id,
- weight=weight,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- balancer_id: Optional[pulumi.Input[str]] = None,
- host: Optional[pulumi.Input[str]] = None,
- name: Optional[pulumi.Input[str]] = None,
- port: Optional[pulumi.Input[int]] = None,
- tags: Optional[pulumi.Input[Sequence[pulumi.Input['TargetTagArgs']]]] = None,
- target_set_id: Optional[pulumi.Input[str]] = None,
- weight: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if balancer_id is None and 'balancerId' in kwargs:
- balancer_id = kwargs['balancerId']
- if target_set_id is None and 'targetSetId' in kwargs:
- target_set_id = kwargs['targetSetId']
-
if balancer_id is not None:
- _setter("balancer_id", balancer_id)
+ pulumi.set(__self__, "balancer_id", balancer_id)
if host is not None:
- _setter("host", host)
+ pulumi.set(__self__, "host", host)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if port is not None:
- _setter("port", port)
+ pulumi.set(__self__, "port", port)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
if target_set_id is not None:
- _setter("target_set_id", target_set_id)
+ pulumi.set(__self__, "target_set_id", target_set_id)
if weight is not None:
- _setter("weight", weight)
+ pulumi.set(__self__, "weight", weight)
@property
@pulumi.getter(name="balancerId")
@@ -291,10 +229,6 @@ def __init__(__self__, resource_name: str, *args, **kwargs):
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
- kwargs = kwargs or {}
- def _setter(key, value):
- kwargs[key] = value
- TargetArgs._configure(_setter, **kwargs)
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
diff --git a/sdk/python/pulumi_spotinst/multai/target_set.py b/sdk/python/pulumi_spotinst/multai/target_set.py
index 553d3166..3be22ffa 100644
--- a/sdk/python/pulumi_spotinst/multai/target_set.py
+++ b/sdk/python/pulumi_spotinst/multai/target_set.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs
from ._inputs import *
@@ -27,58 +27,17 @@ def __init__(__self__, *,
"""
The set of arguments for constructing a TargetSet resource.
"""
- TargetSetArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- balancer_id=balancer_id,
- deployment_id=deployment_id,
- health_check=health_check,
- protocol=protocol,
- weight=weight,
- name=name,
- port=port,
- tags=tags,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- balancer_id: Optional[pulumi.Input[str]] = None,
- deployment_id: Optional[pulumi.Input[str]] = None,
- health_check: Optional[pulumi.Input['TargetSetHealthCheckArgs']] = None,
- protocol: Optional[pulumi.Input[str]] = None,
- weight: Optional[pulumi.Input[int]] = None,
- name: Optional[pulumi.Input[str]] = None,
- port: Optional[pulumi.Input[int]] = None,
- tags: Optional[pulumi.Input[Sequence[pulumi.Input['TargetSetTagArgs']]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if balancer_id is None and 'balancerId' in kwargs:
- balancer_id = kwargs['balancerId']
- if balancer_id is None:
- raise TypeError("Missing 'balancer_id' argument")
- if deployment_id is None and 'deploymentId' in kwargs:
- deployment_id = kwargs['deploymentId']
- if deployment_id is None:
- raise TypeError("Missing 'deployment_id' argument")
- if health_check is None and 'healthCheck' in kwargs:
- health_check = kwargs['healthCheck']
- if health_check is None:
- raise TypeError("Missing 'health_check' argument")
- if protocol is None:
- raise TypeError("Missing 'protocol' argument")
- if weight is None:
- raise TypeError("Missing 'weight' argument")
-
- _setter("balancer_id", balancer_id)
- _setter("deployment_id", deployment_id)
- _setter("health_check", health_check)
- _setter("protocol", protocol)
- _setter("weight", weight)
+ pulumi.set(__self__, "balancer_id", balancer_id)
+ pulumi.set(__self__, "deployment_id", deployment_id)
+ pulumi.set(__self__, "health_check", health_check)
+ pulumi.set(__self__, "protocol", protocol)
+ pulumi.set(__self__, "weight", weight)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if port is not None:
- _setter("port", port)
+ pulumi.set(__self__, "port", port)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
@property
@pulumi.getter(name="balancerId")
@@ -167,53 +126,22 @@ def __init__(__self__, *,
"""
Input properties used for looking up and filtering TargetSet resources.
"""
- _TargetSetState._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- balancer_id=balancer_id,
- deployment_id=deployment_id,
- health_check=health_check,
- name=name,
- port=port,
- protocol=protocol,
- tags=tags,
- weight=weight,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- balancer_id: Optional[pulumi.Input[str]] = None,
- deployment_id: Optional[pulumi.Input[str]] = None,
- health_check: Optional[pulumi.Input['TargetSetHealthCheckArgs']] = None,
- name: Optional[pulumi.Input[str]] = None,
- port: Optional[pulumi.Input[int]] = None,
- protocol: Optional[pulumi.Input[str]] = None,
- tags: Optional[pulumi.Input[Sequence[pulumi.Input['TargetSetTagArgs']]]] = None,
- weight: Optional[pulumi.Input[int]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if balancer_id is None and 'balancerId' in kwargs:
- balancer_id = kwargs['balancerId']
- if deployment_id is None and 'deploymentId' in kwargs:
- deployment_id = kwargs['deploymentId']
- if health_check is None and 'healthCheck' in kwargs:
- health_check = kwargs['healthCheck']
-
if balancer_id is not None:
- _setter("balancer_id", balancer_id)
+ pulumi.set(__self__, "balancer_id", balancer_id)
if deployment_id is not None:
- _setter("deployment_id", deployment_id)
+ pulumi.set(__self__, "deployment_id", deployment_id)
if health_check is not None:
- _setter("health_check", health_check)
+ pulumi.set(__self__, "health_check", health_check)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if port is not None:
- _setter("port", port)
+ pulumi.set(__self__, "port", port)
if protocol is not None:
- _setter("protocol", protocol)
+ pulumi.set(__self__, "protocol", protocol)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
if weight is not None:
- _setter("weight", weight)
+ pulumi.set(__self__, "weight", weight)
@property
@pulumi.getter(name="balancerId")
@@ -325,10 +253,6 @@ def __init__(__self__, resource_name: str, *args, **kwargs):
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
- kwargs = kwargs or {}
- def _setter(key, value):
- kwargs[key] = value
- TargetSetArgs._configure(_setter, **kwargs)
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
@@ -357,7 +281,6 @@ def _internal_init(__self__,
if deployment_id is None and not opts.urn:
raise TypeError("Missing required property 'deployment_id'")
__props__.__dict__["deployment_id"] = deployment_id
- health_check = _utilities.configure(health_check, TargetSetHealthCheckArgs, True)
if health_check is None and not opts.urn:
raise TypeError("Missing required property 'health_check'")
__props__.__dict__["health_check"] = health_check
diff --git a/sdk/python/pulumi_spotinst/organization/_inputs.py b/sdk/python/pulumi_spotinst/organization/_inputs.py
index fb55f3ba..c0e1f670 100644
--- a/sdk/python/pulumi_spotinst/organization/_inputs.py
+++ b/sdk/python/pulumi_spotinst/organization/_inputs.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
__all__ = [
@@ -25,20 +25,7 @@ def __init__(__self__, *,
"""
:param pulumi.Input[Sequence[pulumi.Input['PolicyPolicyContentStatementArgs']]] statements: List of permissions statements.
"""
- PolicyPolicyContentArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- statements=statements,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- statements: Optional[pulumi.Input[Sequence[pulumi.Input['PolicyPolicyContentStatementArgs']]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if statements is None:
- raise TypeError("Missing 'statements' argument")
-
- _setter("statements", statements)
+ pulumi.set(__self__, "statements", statements)
@property
@pulumi.getter
@@ -65,30 +52,9 @@ def __init__(__self__, *,
:param pulumi.Input[str] effect: Valid values "ALLOW", "DENY".
:param pulumi.Input[Sequence[pulumi.Input[str]]] resources: Set a list of resources IDs. In order to include all resources in this statement - use "*".
"""
- PolicyPolicyContentStatementArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- actions=actions,
- effect=effect,
- resources=resources,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- actions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- effect: Optional[pulumi.Input[str]] = None,
- resources: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if actions is None:
- raise TypeError("Missing 'actions' argument")
- if effect is None:
- raise TypeError("Missing 'effect' argument")
- if resources is None:
- raise TypeError("Missing 'resources' argument")
-
- _setter("actions", actions)
- _setter("effect", effect)
- _setter("resources", resources)
+ pulumi.set(__self__, "actions", actions)
+ pulumi.set(__self__, "effect", effect)
+ pulumi.set(__self__, "resources", resources)
@property
@pulumi.getter
@@ -138,29 +104,8 @@ def __init__(__self__, *,
:param pulumi.Input[str] account_role: (Enum: `"viewer", "editor") Role to be associated with the
programmatic user for this account.
"""
- ProgrammaticUserAccountArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- account_id=account_id,
- account_role=account_role,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- account_id: Optional[pulumi.Input[str]] = None,
- account_role: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if account_id is None and 'accountId' in kwargs:
- account_id = kwargs['accountId']
- if account_id is None:
- raise TypeError("Missing 'account_id' argument")
- if account_role is None and 'accountRole' in kwargs:
- account_role = kwargs['accountRole']
- if account_role is None:
- raise TypeError("Missing 'account_role' argument")
-
- _setter("account_id", account_id)
- _setter("account_role", account_role)
+ pulumi.set(__self__, "account_id", account_id)
+ pulumi.set(__self__, "account_role", account_role)
@property
@pulumi.getter(name="accountId")
@@ -198,29 +143,8 @@ def __init__(__self__, *,
enforced for the user.
:param pulumi.Input[str] policy_id: Policy ID the programmatic user will have access to.
"""
- ProgrammaticUserPolicyArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- policy_account_ids=policy_account_ids,
- policy_id=policy_id,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- policy_account_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- policy_id: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if policy_account_ids is None and 'policyAccountIds' in kwargs:
- policy_account_ids = kwargs['policyAccountIds']
- if policy_account_ids is None:
- raise TypeError("Missing 'policy_account_ids' argument")
- if policy_id is None and 'policyId' in kwargs:
- policy_id = kwargs['policyId']
- if policy_id is None:
- raise TypeError("Missing 'policy_id' argument")
-
- _setter("policy_account_ids", policy_account_ids)
- _setter("policy_id", policy_id)
+ pulumi.set(__self__, "policy_account_ids", policy_account_ids)
+ pulumi.set(__self__, "policy_id", policy_id)
@property
@pulumi.getter(name="policyAccountIds")
@@ -259,29 +183,8 @@ def __init__(__self__, *,
:param pulumi.Input[str] policy_id: A policy to register under the given group
(should be existing policy only).
"""
- UserGroupPolicyArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- account_ids=account_ids,
- policy_id=policy_id,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- account_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- policy_id: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if account_ids is None and 'accountIds' in kwargs:
- account_ids = kwargs['accountIds']
- if account_ids is None:
- raise TypeError("Missing 'account_ids' argument")
- if policy_id is None and 'policyId' in kwargs:
- policy_id = kwargs['policyId']
- if policy_id is None:
- raise TypeError("Missing 'policy_id' argument")
-
- _setter("account_ids", account_ids)
- _setter("policy_id", policy_id)
+ pulumi.set(__self__, "account_ids", account_ids)
+ pulumi.set(__self__, "policy_id", policy_id)
@property
@pulumi.getter(name="accountIds")
@@ -319,29 +222,8 @@ def __init__(__self__, *,
:param pulumi.Input[str] policy_id: A policy to register under the given group
(should be existing policy only).
"""
- UserPolicyArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- policy_account_ids=policy_account_ids,
- policy_id=policy_id,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- policy_account_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- policy_id: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if policy_account_ids is None and 'policyAccountIds' in kwargs:
- policy_account_ids = kwargs['policyAccountIds']
- if policy_account_ids is None:
- raise TypeError("Missing 'policy_account_ids' argument")
- if policy_id is None and 'policyId' in kwargs:
- policy_id = kwargs['policyId']
- if policy_id is None:
- raise TypeError("Missing 'policy_id' argument")
-
- _setter("policy_account_ids", policy_account_ids)
- _setter("policy_id", policy_id)
+ pulumi.set(__self__, "policy_account_ids", policy_account_ids)
+ pulumi.set(__self__, "policy_id", policy_id)
@property
@pulumi.getter(name="policyAccountIds")
diff --git a/sdk/python/pulumi_spotinst/organization/outputs.py b/sdk/python/pulumi_spotinst/organization/outputs.py
index 032198f6..2daa4eb5 100644
--- a/sdk/python/pulumi_spotinst/organization/outputs.py
+++ b/sdk/python/pulumi_spotinst/organization/outputs.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs
@@ -26,20 +26,7 @@ def __init__(__self__, *,
"""
:param Sequence['PolicyPolicyContentStatementArgs'] statements: List of permissions statements.
"""
- PolicyPolicyContent._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- statements=statements,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- statements: Optional[Sequence['outputs.PolicyPolicyContentStatement']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if statements is None:
- raise TypeError("Missing 'statements' argument")
-
- _setter("statements", statements)
+ pulumi.set(__self__, "statements", statements)
@property
@pulumi.getter
@@ -62,30 +49,9 @@ def __init__(__self__, *,
:param str effect: Valid values "ALLOW", "DENY".
:param Sequence[str] resources: Set a list of resources IDs. In order to include all resources in this statement - use "*".
"""
- PolicyPolicyContentStatement._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- actions=actions,
- effect=effect,
- resources=resources,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- actions: Optional[Sequence[str]] = None,
- effect: Optional[str] = None,
- resources: Optional[Sequence[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if actions is None:
- raise TypeError("Missing 'actions' argument")
- if effect is None:
- raise TypeError("Missing 'effect' argument")
- if resources is None:
- raise TypeError("Missing 'resources' argument")
-
- _setter("actions", actions)
- _setter("effect", effect)
- _setter("resources", resources)
+ pulumi.set(__self__, "actions", actions)
+ pulumi.set(__self__, "effect", effect)
+ pulumi.set(__self__, "resources", resources)
@property
@pulumi.getter
@@ -142,29 +108,8 @@ def __init__(__self__, *,
:param str account_role: (Enum: `"viewer", "editor") Role to be associated with the
programmatic user for this account.
"""
- ProgrammaticUserAccount._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- account_id=account_id,
- account_role=account_role,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- account_id: Optional[str] = None,
- account_role: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if account_id is None and 'accountId' in kwargs:
- account_id = kwargs['accountId']
- if account_id is None:
- raise TypeError("Missing 'account_id' argument")
- if account_role is None and 'accountRole' in kwargs:
- account_role = kwargs['accountRole']
- if account_role is None:
- raise TypeError("Missing 'account_role' argument")
-
- _setter("account_id", account_id)
- _setter("account_role", account_role)
+ pulumi.set(__self__, "account_id", account_id)
+ pulumi.set(__self__, "account_role", account_role)
@property
@pulumi.getter(name="accountId")
@@ -213,29 +158,8 @@ def __init__(__self__, *,
enforced for the user.
:param str policy_id: Policy ID the programmatic user will have access to.
"""
- ProgrammaticUserPolicy._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- policy_account_ids=policy_account_ids,
- policy_id=policy_id,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- policy_account_ids: Optional[Sequence[str]] = None,
- policy_id: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if policy_account_ids is None and 'policyAccountIds' in kwargs:
- policy_account_ids = kwargs['policyAccountIds']
- if policy_account_ids is None:
- raise TypeError("Missing 'policy_account_ids' argument")
- if policy_id is None and 'policyId' in kwargs:
- policy_id = kwargs['policyId']
- if policy_id is None:
- raise TypeError("Missing 'policy_id' argument")
-
- _setter("policy_account_ids", policy_account_ids)
- _setter("policy_id", policy_id)
+ pulumi.set(__self__, "policy_account_ids", policy_account_ids)
+ pulumi.set(__self__, "policy_id", policy_id)
@property
@pulumi.getter(name="policyAccountIds")
@@ -285,29 +209,8 @@ def __init__(__self__, *,
:param str policy_id: A policy to register under the given group
(should be existing policy only).
"""
- UserGroupPolicy._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- account_ids=account_ids,
- policy_id=policy_id,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- account_ids: Optional[Sequence[str]] = None,
- policy_id: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if account_ids is None and 'accountIds' in kwargs:
- account_ids = kwargs['accountIds']
- if account_ids is None:
- raise TypeError("Missing 'account_ids' argument")
- if policy_id is None and 'policyId' in kwargs:
- policy_id = kwargs['policyId']
- if policy_id is None:
- raise TypeError("Missing 'policy_id' argument")
-
- _setter("account_ids", account_ids)
- _setter("policy_id", policy_id)
+ pulumi.set(__self__, "account_ids", account_ids)
+ pulumi.set(__self__, "policy_id", policy_id)
@property
@pulumi.getter(name="accountIds")
@@ -356,29 +259,8 @@ def __init__(__self__, *,
:param str policy_id: A policy to register under the given group
(should be existing policy only).
"""
- UserPolicy._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- policy_account_ids=policy_account_ids,
- policy_id=policy_id,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- policy_account_ids: Optional[Sequence[str]] = None,
- policy_id: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if policy_account_ids is None and 'policyAccountIds' in kwargs:
- policy_account_ids = kwargs['policyAccountIds']
- if policy_account_ids is None:
- raise TypeError("Missing 'policy_account_ids' argument")
- if policy_id is None and 'policyId' in kwargs:
- policy_id = kwargs['policyId']
- if policy_id is None:
- raise TypeError("Missing 'policy_id' argument")
-
- _setter("policy_account_ids", policy_account_ids)
- _setter("policy_id", policy_id)
+ pulumi.set(__self__, "policy_account_ids", policy_account_ids)
+ pulumi.set(__self__, "policy_id", policy_id)
@property
@pulumi.getter(name="policyAccountIds")
diff --git a/sdk/python/pulumi_spotinst/organization/policy.py b/sdk/python/pulumi_spotinst/organization/policy.py
index fa5bcd07..f2daab4b 100644
--- a/sdk/python/pulumi_spotinst/organization/policy.py
+++ b/sdk/python/pulumi_spotinst/organization/policy.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs
from ._inputs import *
@@ -25,30 +25,11 @@ def __init__(__self__, *,
:param pulumi.Input[str] description: Short description of policy.
:param pulumi.Input[str] name: Name of the Policy.
"""
- PolicyArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- policy_contents=policy_contents,
- description=description,
- name=name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- policy_contents: Optional[pulumi.Input[Sequence[pulumi.Input['PolicyPolicyContentArgs']]]] = None,
- description: Optional[pulumi.Input[str]] = None,
- name: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if policy_contents is None and 'policyContents' in kwargs:
- policy_contents = kwargs['policyContents']
- if policy_contents is None:
- raise TypeError("Missing 'policy_contents' argument")
-
- _setter("policy_contents", policy_contents)
+ pulumi.set(__self__, "policy_contents", policy_contents)
if description is not None:
- _setter("description", description)
+ pulumi.set(__self__, "description", description)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
@property
@pulumi.getter(name="policyContents")
@@ -99,29 +80,12 @@ def __init__(__self__, *,
:param pulumi.Input[str] name: Name of the Policy.
:param pulumi.Input[Sequence[pulumi.Input['PolicyPolicyContentArgs']]] policy_contents: Set permissions objects list.
"""
- _PolicyState._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- description=description,
- name=name,
- policy_contents=policy_contents,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- description: Optional[pulumi.Input[str]] = None,
- name: Optional[pulumi.Input[str]] = None,
- policy_contents: Optional[pulumi.Input[Sequence[pulumi.Input['PolicyPolicyContentArgs']]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if policy_contents is None and 'policyContents' in kwargs:
- policy_contents = kwargs['policyContents']
-
if description is not None:
- _setter("description", description)
+ pulumi.set(__self__, "description", description)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if policy_contents is not None:
- _setter("policy_contents", policy_contents)
+ pulumi.set(__self__, "policy_contents", policy_contents)
@property
@pulumi.getter
@@ -257,10 +221,6 @@ def __init__(__self__, resource_name: str, *args, **kwargs):
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
- kwargs = kwargs or {}
- def _setter(key, value):
- kwargs[key] = value
- PolicyArgs._configure(_setter, **kwargs)
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
diff --git a/sdk/python/pulumi_spotinst/organization/programmatic_user.py b/sdk/python/pulumi_spotinst/organization/programmatic_user.py
index 1304e4cc..179ce890 100644
--- a/sdk/python/pulumi_spotinst/organization/programmatic_user.py
+++ b/sdk/python/pulumi_spotinst/organization/programmatic_user.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs
from ._inputs import *
@@ -31,37 +31,16 @@ def __init__(__self__, *,
If used - Cannot be empty.
:param pulumi.Input[Sequence[pulumi.Input[str]]] user_group_ids: A list of the user groups to register the given user to (should be existing user groups only)
"""
- ProgrammaticUserArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- accounts=accounts,
- description=description,
- name=name,
- policies=policies,
- user_group_ids=user_group_ids,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- accounts: Optional[pulumi.Input[Sequence[pulumi.Input['ProgrammaticUserAccountArgs']]]] = None,
- description: Optional[pulumi.Input[str]] = None,
- name: Optional[pulumi.Input[str]] = None,
- policies: Optional[pulumi.Input[Sequence[pulumi.Input['ProgrammaticUserPolicyArgs']]]] = None,
- user_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if user_group_ids is None and 'userGroupIds' in kwargs:
- user_group_ids = kwargs['userGroupIds']
-
if accounts is not None:
- _setter("accounts", accounts)
+ pulumi.set(__self__, "accounts", accounts)
if description is not None:
- _setter("description", description)
+ pulumi.set(__self__, "description", description)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if policies is not None:
- _setter("policies", policies)
+ pulumi.set(__self__, "policies", policies)
if user_group_ids is not None:
- _setter("user_group_ids", user_group_ids)
+ pulumi.set(__self__, "user_group_ids", user_group_ids)
@property
@pulumi.getter
@@ -144,37 +123,16 @@ def __init__(__self__, *,
If used - Cannot be empty.
:param pulumi.Input[Sequence[pulumi.Input[str]]] user_group_ids: A list of the user groups to register the given user to (should be existing user groups only)
"""
- _ProgrammaticUserState._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- accounts=accounts,
- description=description,
- name=name,
- policies=policies,
- user_group_ids=user_group_ids,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- accounts: Optional[pulumi.Input[Sequence[pulumi.Input['ProgrammaticUserAccountArgs']]]] = None,
- description: Optional[pulumi.Input[str]] = None,
- name: Optional[pulumi.Input[str]] = None,
- policies: Optional[pulumi.Input[Sequence[pulumi.Input['ProgrammaticUserPolicyArgs']]]] = None,
- user_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if user_group_ids is None and 'userGroupIds' in kwargs:
- user_group_ids = kwargs['userGroupIds']
-
if accounts is not None:
- _setter("accounts", accounts)
+ pulumi.set(__self__, "accounts", accounts)
if description is not None:
- _setter("description", description)
+ pulumi.set(__self__, "description", description)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if policies is not None:
- _setter("policies", policies)
+ pulumi.set(__self__, "policies", policies)
if user_group_ids is not None:
- _setter("user_group_ids", user_group_ids)
+ pulumi.set(__self__, "user_group_ids", user_group_ids)
@property
@pulumi.getter
@@ -318,10 +276,6 @@ def __init__(__self__, resource_name: str, *args, **kwargs):
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
- kwargs = kwargs or {}
- def _setter(key, value):
- kwargs[key] = value
- ProgrammaticUserArgs._configure(_setter, **kwargs)
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
diff --git a/sdk/python/pulumi_spotinst/organization/user.py b/sdk/python/pulumi_spotinst/organization/user.py
index 75efde35..cb64c7ad 100644
--- a/sdk/python/pulumi_spotinst/organization/user.py
+++ b/sdk/python/pulumi_spotinst/organization/user.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs
from ._inputs import *
@@ -34,52 +34,17 @@ def __init__(__self__, *,
:param pulumi.Input[str] role: User's role.
:param pulumi.Input[Sequence[pulumi.Input[str]]] user_group_ids: A list of the user groups to register the given user to (should be existing user groups only)
"""
- UserArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- email=email,
- first_name=first_name,
- last_name=last_name,
- password=password,
- policies=policies,
- role=role,
- user_group_ids=user_group_ids,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- email: Optional[pulumi.Input[str]] = None,
- first_name: Optional[pulumi.Input[str]] = None,
- last_name: Optional[pulumi.Input[str]] = None,
- password: Optional[pulumi.Input[str]] = None,
- policies: Optional[pulumi.Input[Sequence[pulumi.Input['UserPolicyArgs']]]] = None,
- role: Optional[pulumi.Input[str]] = None,
- user_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if email is None:
- raise TypeError("Missing 'email' argument")
- if first_name is None and 'firstName' in kwargs:
- first_name = kwargs['firstName']
- if first_name is None:
- raise TypeError("Missing 'first_name' argument")
- if last_name is None and 'lastName' in kwargs:
- last_name = kwargs['lastName']
- if last_name is None:
- raise TypeError("Missing 'last_name' argument")
- if user_group_ids is None and 'userGroupIds' in kwargs:
- user_group_ids = kwargs['userGroupIds']
-
- _setter("email", email)
- _setter("first_name", first_name)
- _setter("last_name", last_name)
+ pulumi.set(__self__, "email", email)
+ pulumi.set(__self__, "first_name", first_name)
+ pulumi.set(__self__, "last_name", last_name)
if password is not None:
- _setter("password", password)
+ pulumi.set(__self__, "password", password)
if policies is not None:
- _setter("policies", policies)
+ pulumi.set(__self__, "policies", policies)
if role is not None:
- _setter("role", role)
+ pulumi.set(__self__, "role", role)
if user_group_ids is not None:
- _setter("user_group_ids", user_group_ids)
+ pulumi.set(__self__, "user_group_ids", user_group_ids)
@property
@pulumi.getter
@@ -188,49 +153,20 @@ def __init__(__self__, *,
:param pulumi.Input[str] role: User's role.
:param pulumi.Input[Sequence[pulumi.Input[str]]] user_group_ids: A list of the user groups to register the given user to (should be existing user groups only)
"""
- _UserState._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- email=email,
- first_name=first_name,
- last_name=last_name,
- password=password,
- policies=policies,
- role=role,
- user_group_ids=user_group_ids,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- email: Optional[pulumi.Input[str]] = None,
- first_name: Optional[pulumi.Input[str]] = None,
- last_name: Optional[pulumi.Input[str]] = None,
- password: Optional[pulumi.Input[str]] = None,
- policies: Optional[pulumi.Input[Sequence[pulumi.Input['UserPolicyArgs']]]] = None,
- role: Optional[pulumi.Input[str]] = None,
- user_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if first_name is None and 'firstName' in kwargs:
- first_name = kwargs['firstName']
- if last_name is None and 'lastName' in kwargs:
- last_name = kwargs['lastName']
- if user_group_ids is None and 'userGroupIds' in kwargs:
- user_group_ids = kwargs['userGroupIds']
-
if email is not None:
- _setter("email", email)
+ pulumi.set(__self__, "email", email)
if first_name is not None:
- _setter("first_name", first_name)
+ pulumi.set(__self__, "first_name", first_name)
if last_name is not None:
- _setter("last_name", last_name)
+ pulumi.set(__self__, "last_name", last_name)
if password is not None:
- _setter("password", password)
+ pulumi.set(__self__, "password", password)
if policies is not None:
- _setter("policies", policies)
+ pulumi.set(__self__, "policies", policies)
if role is not None:
- _setter("role", role)
+ pulumi.set(__self__, "role", role)
if user_group_ids is not None:
- _setter("user_group_ids", user_group_ids)
+ pulumi.set(__self__, "user_group_ids", user_group_ids)
@property
@pulumi.getter
@@ -408,10 +344,6 @@ def __init__(__self__, resource_name: str, *args, **kwargs):
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
- kwargs = kwargs or {}
- def _setter(key, value):
- kwargs[key] = value
- UserArgs._configure(_setter, **kwargs)
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
diff --git a/sdk/python/pulumi_spotinst/organization/user_group.py b/sdk/python/pulumi_spotinst/organization/user_group.py
index 2b1c5ff2..65f5d035 100644
--- a/sdk/python/pulumi_spotinst/organization/user_group.py
+++ b/sdk/python/pulumi_spotinst/organization/user_group.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs
from ._inputs import *
@@ -29,33 +29,14 @@ def __init__(__self__, *,
:param pulumi.Input[Sequence[pulumi.Input[str]]] user_ids: The users to register under the created group
(should be existing users only).
"""
- UserGroupArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- description=description,
- name=name,
- policies=policies,
- user_ids=user_ids,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- description: Optional[pulumi.Input[str]] = None,
- name: Optional[pulumi.Input[str]] = None,
- policies: Optional[pulumi.Input[Sequence[pulumi.Input['UserGroupPolicyArgs']]]] = None,
- user_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if user_ids is None and 'userIds' in kwargs:
- user_ids = kwargs['userIds']
-
if description is not None:
- _setter("description", description)
+ pulumi.set(__self__, "description", description)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if policies is not None:
- _setter("policies", policies)
+ pulumi.set(__self__, "policies", policies)
if user_ids is not None:
- _setter("user_ids", user_ids)
+ pulumi.set(__self__, "user_ids", user_ids)
@property
@pulumi.getter
@@ -124,33 +105,14 @@ def __init__(__self__, *,
:param pulumi.Input[Sequence[pulumi.Input[str]]] user_ids: The users to register under the created group
(should be existing users only).
"""
- _UserGroupState._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- description=description,
- name=name,
- policies=policies,
- user_ids=user_ids,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- description: Optional[pulumi.Input[str]] = None,
- name: Optional[pulumi.Input[str]] = None,
- policies: Optional[pulumi.Input[Sequence[pulumi.Input['UserGroupPolicyArgs']]]] = None,
- user_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if user_ids is None and 'userIds' in kwargs:
- user_ids = kwargs['userIds']
-
if description is not None:
- _setter("description", description)
+ pulumi.set(__self__, "description", description)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if policies is not None:
- _setter("policies", policies)
+ pulumi.set(__self__, "policies", policies)
if user_ids is not None:
- _setter("user_ids", user_ids)
+ pulumi.set(__self__, "user_ids", user_ids)
@property
@pulumi.getter
@@ -274,10 +236,6 @@ def __init__(__self__, resource_name: str, *args, **kwargs):
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
- kwargs = kwargs or {}
- def _setter(key, value):
- kwargs[key] = value
- UserGroupArgs._configure(_setter, **kwargs)
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
diff --git a/sdk/python/pulumi_spotinst/outputs.py b/sdk/python/pulumi_spotinst/outputs.py
index 436ca8d2..c973e658 100644
--- a/sdk/python/pulumi_spotinst/outputs.py
+++ b/sdk/python/pulumi_spotinst/outputs.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from . import _utilities
from . import outputs
@@ -84,26 +84,9 @@ def __init__(__self__, *,
"""
:param str subdir: The subdirectory in which your files will be stored within the bucket. Adds the prefix subdir/ to new objects' keys. Can't be null or contain '/'.
"""
- DataIntegrationS3._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- bucket_name=bucket_name,
- subdir=subdir,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- bucket_name: Optional[str] = None,
- subdir: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if bucket_name is None and 'bucketName' in kwargs:
- bucket_name = kwargs['bucketName']
- if bucket_name is None:
- raise TypeError("Missing 'bucket_name' argument")
-
- _setter("bucket_name", bucket_name)
+ pulumi.set(__self__, "bucket_name", bucket_name)
if subdir is not None:
- _setter("subdir", subdir)
+ pulumi.set(__self__, "subdir", subdir)
@property
@pulumi.getter(name="bucketName")
@@ -124,23 +107,10 @@ class ElastigroupAzureV3Image(dict):
def __init__(__self__, *,
customs: Optional[Sequence['outputs.ElastigroupAzureV3ImageCustom']] = None,
marketplaces: Optional[Sequence['outputs.ElastigroupAzureV3ImageMarketplace']] = None):
- ElastigroupAzureV3Image._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- customs=customs,
- marketplaces=marketplaces,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- customs: Optional[Sequence['outputs.ElastigroupAzureV3ImageCustom']] = None,
- marketplaces: Optional[Sequence['outputs.ElastigroupAzureV3ImageMarketplace']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if customs is not None:
- _setter("customs", customs)
+ pulumi.set(__self__, "customs", customs)
if marketplaces is not None:
- _setter("marketplaces", marketplaces)
+ pulumi.set(__self__, "marketplaces", marketplaces)
@property
@pulumi.getter
@@ -177,29 +147,8 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
image_name: str,
resource_group_name: str):
- ElastigroupAzureV3ImageCustom._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- image_name=image_name,
- resource_group_name=resource_group_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- image_name: Optional[str] = None,
- resource_group_name: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if image_name is None and 'imageName' in kwargs:
- image_name = kwargs['imageName']
- if image_name is None:
- raise TypeError("Missing 'image_name' argument")
- if resource_group_name is None and 'resourceGroupName' in kwargs:
- resource_group_name = kwargs['resourceGroupName']
- if resource_group_name is None:
- raise TypeError("Missing 'resource_group_name' argument")
-
- _setter("image_name", image_name)
- _setter("resource_group_name", resource_group_name)
+ pulumi.set(__self__, "image_name", image_name)
+ pulumi.set(__self__, "resource_group_name", resource_group_name)
@property
@pulumi.getter(name="imageName")
@@ -219,35 +168,10 @@ def __init__(__self__, *,
publisher: str,
sku: str,
version: str):
- ElastigroupAzureV3ImageMarketplace._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- offer=offer,
- publisher=publisher,
- sku=sku,
- version=version,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- offer: Optional[str] = None,
- publisher: Optional[str] = None,
- sku: Optional[str] = None,
- version: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if offer is None:
- raise TypeError("Missing 'offer' argument")
- if publisher is None:
- raise TypeError("Missing 'publisher' argument")
- if sku is None:
- raise TypeError("Missing 'sku' argument")
- if version is None:
- raise TypeError("Missing 'version' argument")
-
- _setter("offer", offer)
- _setter("publisher", publisher)
- _setter("sku", sku)
- _setter("version", version)
+ pulumi.set(__self__, "offer", offer)
+ pulumi.set(__self__, "publisher", publisher)
+ pulumi.set(__self__, "sku", sku)
+ pulumi.set(__self__, "version", version)
@property
@pulumi.getter
@@ -295,32 +219,11 @@ def __init__(__self__, *,
user_name: str,
password: Optional[str] = None,
ssh_public_key: Optional[str] = None):
- ElastigroupAzureV3Login._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- user_name=user_name,
- password=password,
- ssh_public_key=ssh_public_key,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- user_name: Optional[str] = None,
- password: Optional[str] = None,
- ssh_public_key: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if user_name is None and 'userName' in kwargs:
- user_name = kwargs['userName']
- if user_name is None:
- raise TypeError("Missing 'user_name' argument")
- if ssh_public_key is None and 'sshPublicKey' in kwargs:
- ssh_public_key = kwargs['sshPublicKey']
-
- _setter("user_name", user_name)
+ pulumi.set(__self__, "user_name", user_name)
if password is not None:
- _setter("password", password)
+ pulumi.set(__self__, "password", password)
if ssh_public_key is not None:
- _setter("ssh_public_key", ssh_public_key)
+ pulumi.set(__self__, "ssh_public_key", ssh_public_key)
@property
@pulumi.getter(name="userName")
@@ -360,27 +263,8 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
name: str,
resource_group_name: str):
- ElastigroupAzureV3ManagedServiceIdentity._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- resource_group_name=resource_group_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[str] = None,
- resource_group_name: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
- if resource_group_name is None and 'resourceGroupName' in kwargs:
- resource_group_name = kwargs['resourceGroupName']
- if resource_group_name is None:
- raise TypeError("Missing 'resource_group_name' argument")
-
- _setter("name", name)
- _setter("resource_group_name", resource_group_name)
+ pulumi.set(__self__, "name", name)
+ pulumi.set(__self__, "resource_group_name", resource_group_name)
@property
@pulumi.getter
@@ -420,36 +304,9 @@ def __init__(__self__, *,
network_interfaces: Sequence['outputs.ElastigroupAzureV3NetworkNetworkInterface'],
resource_group_name: str,
virtual_network_name: str):
- ElastigroupAzureV3Network._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- network_interfaces=network_interfaces,
- resource_group_name=resource_group_name,
- virtual_network_name=virtual_network_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- network_interfaces: Optional[Sequence['outputs.ElastigroupAzureV3NetworkNetworkInterface']] = None,
- resource_group_name: Optional[str] = None,
- virtual_network_name: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if network_interfaces is None and 'networkInterfaces' in kwargs:
- network_interfaces = kwargs['networkInterfaces']
- if network_interfaces is None:
- raise TypeError("Missing 'network_interfaces' argument")
- if resource_group_name is None and 'resourceGroupName' in kwargs:
- resource_group_name = kwargs['resourceGroupName']
- if resource_group_name is None:
- raise TypeError("Missing 'resource_group_name' argument")
- if virtual_network_name is None and 'virtualNetworkName' in kwargs:
- virtual_network_name = kwargs['virtualNetworkName']
- if virtual_network_name is None:
- raise TypeError("Missing 'virtual_network_name' argument")
-
- _setter("network_interfaces", network_interfaces)
- _setter("resource_group_name", resource_group_name)
- _setter("virtual_network_name", virtual_network_name)
+ pulumi.set(__self__, "network_interfaces", network_interfaces)
+ pulumi.set(__self__, "resource_group_name", resource_group_name)
+ pulumi.set(__self__, "virtual_network_name", virtual_network_name)
@property
@pulumi.getter(name="networkInterfaces")
@@ -500,48 +357,13 @@ def __init__(__self__, *,
subnet_name: str,
additional_ip_configs: Optional[Sequence['outputs.ElastigroupAzureV3NetworkNetworkInterfaceAdditionalIpConfig']] = None,
application_security_groups: Optional[Sequence['outputs.ElastigroupAzureV3NetworkNetworkInterfaceApplicationSecurityGroup']] = None):
- ElastigroupAzureV3NetworkNetworkInterface._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- assign_public_ip=assign_public_ip,
- is_primary=is_primary,
- subnet_name=subnet_name,
- additional_ip_configs=additional_ip_configs,
- application_security_groups=application_security_groups,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- assign_public_ip: Optional[bool] = None,
- is_primary: Optional[bool] = None,
- subnet_name: Optional[str] = None,
- additional_ip_configs: Optional[Sequence['outputs.ElastigroupAzureV3NetworkNetworkInterfaceAdditionalIpConfig']] = None,
- application_security_groups: Optional[Sequence['outputs.ElastigroupAzureV3NetworkNetworkInterfaceApplicationSecurityGroup']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if assign_public_ip is None and 'assignPublicIp' in kwargs:
- assign_public_ip = kwargs['assignPublicIp']
- if assign_public_ip is None:
- raise TypeError("Missing 'assign_public_ip' argument")
- if is_primary is None and 'isPrimary' in kwargs:
- is_primary = kwargs['isPrimary']
- if is_primary is None:
- raise TypeError("Missing 'is_primary' argument")
- if subnet_name is None and 'subnetName' in kwargs:
- subnet_name = kwargs['subnetName']
- if subnet_name is None:
- raise TypeError("Missing 'subnet_name' argument")
- if additional_ip_configs is None and 'additionalIpConfigs' in kwargs:
- additional_ip_configs = kwargs['additionalIpConfigs']
- if application_security_groups is None and 'applicationSecurityGroups' in kwargs:
- application_security_groups = kwargs['applicationSecurityGroups']
-
- _setter("assign_public_ip", assign_public_ip)
- _setter("is_primary", is_primary)
- _setter("subnet_name", subnet_name)
+ pulumi.set(__self__, "assign_public_ip", assign_public_ip)
+ pulumi.set(__self__, "is_primary", is_primary)
+ pulumi.set(__self__, "subnet_name", subnet_name)
if additional_ip_configs is not None:
- _setter("additional_ip_configs", additional_ip_configs)
+ pulumi.set(__self__, "additional_ip_configs", additional_ip_configs)
if application_security_groups is not None:
- _setter("application_security_groups", application_security_groups)
+ pulumi.set(__self__, "application_security_groups", application_security_groups)
@property
@pulumi.getter(name="assignPublicIp")
@@ -591,26 +413,9 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
name: str,
private_ip_version: Optional[str] = None):
- ElastigroupAzureV3NetworkNetworkInterfaceAdditionalIpConfig._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- private_ip_version=private_ip_version,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[str] = None,
- private_ip_version: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
- if private_ip_version is None and 'privateIpVersion' in kwargs:
- private_ip_version = kwargs['privateIpVersion']
-
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if private_ip_version is not None:
- _setter("private_ip_version", private_ip_version)
+ pulumi.set(__self__, "private_ip_version", private_ip_version)
@property
@pulumi.getter
@@ -645,27 +450,8 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
name: str,
resource_group_name: str):
- ElastigroupAzureV3NetworkNetworkInterfaceApplicationSecurityGroup._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- resource_group_name=resource_group_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[str] = None,
- resource_group_name: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
- if resource_group_name is None and 'resourceGroupName' in kwargs:
- resource_group_name = kwargs['resourceGroupName']
- if resource_group_name is None:
- raise TypeError("Missing 'resource_group_name' argument")
-
- _setter("name", name)
- _setter("resource_group_name", resource_group_name)
+ pulumi.set(__self__, "name", name)
+ pulumi.set(__self__, "resource_group_name", resource_group_name)
@property
@pulumi.getter
@@ -683,25 +469,8 @@ class ElastigroupAzureV3Tag(dict):
def __init__(__self__, *,
key: str,
value: str):
- ElastigroupAzureV3Tag._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- key=key,
- value=value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- key: Optional[str] = None,
- value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if key is None:
- raise TypeError("Missing 'key' argument")
- if value is None:
- raise TypeError("Missing 'value' argument")
-
- _setter("key", key)
- _setter("value", value)
+ pulumi.set(__self__, "key", key)
+ pulumi.set(__self__, "value", value)
@property
@pulumi.getter
@@ -754,60 +523,19 @@ def __init__(__self__, *,
:param str endpoint: The destination for the request.
:param int timeout: the amount of time (in seconds) to wait when receiving a response from the health check.
"""
- HealthCheckCheck._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- healthy=healthy,
- interval=interval,
- port=port,
- protocol=protocol,
- unhealthy=unhealthy,
- end_point=end_point,
- endpoint=endpoint,
- time_out=time_out,
- timeout=timeout,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- healthy: Optional[int] = None,
- interval: Optional[int] = None,
- port: Optional[int] = None,
- protocol: Optional[str] = None,
- unhealthy: Optional[int] = None,
- end_point: Optional[str] = None,
- endpoint: Optional[str] = None,
- time_out: Optional[int] = None,
- timeout: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if healthy is None:
- raise TypeError("Missing 'healthy' argument")
- if interval is None:
- raise TypeError("Missing 'interval' argument")
- if port is None:
- raise TypeError("Missing 'port' argument")
- if protocol is None:
- raise TypeError("Missing 'protocol' argument")
- if unhealthy is None:
- raise TypeError("Missing 'unhealthy' argument")
- if end_point is None and 'endPoint' in kwargs:
- end_point = kwargs['endPoint']
- if time_out is None and 'timeOut' in kwargs:
- time_out = kwargs['timeOut']
-
- _setter("healthy", healthy)
- _setter("interval", interval)
- _setter("port", port)
- _setter("protocol", protocol)
- _setter("unhealthy", unhealthy)
+ pulumi.set(__self__, "healthy", healthy)
+ pulumi.set(__self__, "interval", interval)
+ pulumi.set(__self__, "port", port)
+ pulumi.set(__self__, "protocol", protocol)
+ pulumi.set(__self__, "unhealthy", unhealthy)
if end_point is not None:
- _setter("end_point", end_point)
+ pulumi.set(__self__, "end_point", end_point)
if endpoint is not None:
- _setter("endpoint", endpoint)
+ pulumi.set(__self__, "endpoint", endpoint)
if time_out is not None:
- _setter("time_out", time_out)
+ pulumi.set(__self__, "time_out", time_out)
if timeout is not None:
- _setter("timeout", timeout)
+ pulumi.set(__self__, "timeout", timeout)
@property
@pulumi.getter
@@ -908,51 +636,14 @@ def __init__(__self__, *,
storage_account_type: str,
lun: Optional[int] = None,
zone: Optional[str] = None):
- StatefulNodeAzureAttachDataDisk._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- data_disk_name=data_disk_name,
- data_disk_resource_group_name=data_disk_resource_group_name,
- size_gb=size_gb,
- storage_account_type=storage_account_type,
- lun=lun,
- zone=zone,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- data_disk_name: Optional[str] = None,
- data_disk_resource_group_name: Optional[str] = None,
- size_gb: Optional[int] = None,
- storage_account_type: Optional[str] = None,
- lun: Optional[int] = None,
- zone: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if data_disk_name is None and 'dataDiskName' in kwargs:
- data_disk_name = kwargs['dataDiskName']
- if data_disk_name is None:
- raise TypeError("Missing 'data_disk_name' argument")
- if data_disk_resource_group_name is None and 'dataDiskResourceGroupName' in kwargs:
- data_disk_resource_group_name = kwargs['dataDiskResourceGroupName']
- if data_disk_resource_group_name is None:
- raise TypeError("Missing 'data_disk_resource_group_name' argument")
- if size_gb is None and 'sizeGb' in kwargs:
- size_gb = kwargs['sizeGb']
- if size_gb is None:
- raise TypeError("Missing 'size_gb' argument")
- if storage_account_type is None and 'storageAccountType' in kwargs:
- storage_account_type = kwargs['storageAccountType']
- if storage_account_type is None:
- raise TypeError("Missing 'storage_account_type' argument")
-
- _setter("data_disk_name", data_disk_name)
- _setter("data_disk_resource_group_name", data_disk_resource_group_name)
- _setter("size_gb", size_gb)
- _setter("storage_account_type", storage_account_type)
+ pulumi.set(__self__, "data_disk_name", data_disk_name)
+ pulumi.set(__self__, "data_disk_resource_group_name", data_disk_resource_group_name)
+ pulumi.set(__self__, "size_gb", size_gb)
+ pulumi.set(__self__, "storage_account_type", storage_account_type)
if lun is not None:
- _setter("lun", lun)
+ pulumi.set(__self__, "lun", lun)
if zone is not None:
- _setter("zone", zone)
+ pulumi.set(__self__, "zone", zone)
@property
@pulumi.getter(name="dataDiskName")
@@ -1010,31 +701,12 @@ def __init__(__self__, *,
is_enabled: Optional[bool] = None,
storage_url: Optional[str] = None,
type: Optional[str] = None):
- StatefulNodeAzureBootDiagnostic._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- is_enabled=is_enabled,
- storage_url=storage_url,
- type=type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- is_enabled: Optional[bool] = None,
- storage_url: Optional[str] = None,
- type: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
- if storage_url is None and 'storageUrl' in kwargs:
- storage_url = kwargs['storageUrl']
-
if is_enabled is not None:
- _setter("is_enabled", is_enabled)
+ pulumi.set(__self__, "is_enabled", is_enabled)
if storage_url is not None:
- _setter("storage_url", storage_url)
+ pulumi.set(__self__, "storage_url", storage_url)
if type is not None:
- _setter("type", type)
+ pulumi.set(__self__, "type", type)
@property
@pulumi.getter(name="isEnabled")
@@ -1075,32 +747,9 @@ def __init__(__self__, *,
lun: int,
size_gb: int,
type: str):
- StatefulNodeAzureDataDisk._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- lun=lun,
- size_gb=size_gb,
- type=type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- lun: Optional[int] = None,
- size_gb: Optional[int] = None,
- type: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if lun is None:
- raise TypeError("Missing 'lun' argument")
- if size_gb is None and 'sizeGb' in kwargs:
- size_gb = kwargs['sizeGb']
- if size_gb is None:
- raise TypeError("Missing 'size_gb' argument")
- if type is None:
- raise TypeError("Missing 'type' argument")
-
- _setter("lun", lun)
- _setter("size_gb", size_gb)
- _setter("type", type)
+ pulumi.set(__self__, "lun", lun)
+ pulumi.set(__self__, "size_gb", size_gb)
+ pulumi.set(__self__, "type", type)
@property
@pulumi.getter
@@ -1163,74 +812,19 @@ def __init__(__self__, *,
network_ttl_in_hours: Optional[int] = None,
public_ip_ttl_in_hours: Optional[int] = None,
snapshot_ttl_in_hours: Optional[int] = None):
- StatefulNodeAzureDelete._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- disk_should_deallocate=disk_should_deallocate,
- network_should_deallocate=network_should_deallocate,
- public_ip_should_deallocate=public_ip_should_deallocate,
- should_terminate_vm=should_terminate_vm,
- snapshot_should_deallocate=snapshot_should_deallocate,
- disk_ttl_in_hours=disk_ttl_in_hours,
- network_ttl_in_hours=network_ttl_in_hours,
- public_ip_ttl_in_hours=public_ip_ttl_in_hours,
- snapshot_ttl_in_hours=snapshot_ttl_in_hours,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- disk_should_deallocate: Optional[bool] = None,
- network_should_deallocate: Optional[bool] = None,
- public_ip_should_deallocate: Optional[bool] = None,
- should_terminate_vm: Optional[bool] = None,
- snapshot_should_deallocate: Optional[bool] = None,
- disk_ttl_in_hours: Optional[int] = None,
- network_ttl_in_hours: Optional[int] = None,
- public_ip_ttl_in_hours: Optional[int] = None,
- snapshot_ttl_in_hours: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if disk_should_deallocate is None and 'diskShouldDeallocate' in kwargs:
- disk_should_deallocate = kwargs['diskShouldDeallocate']
- if disk_should_deallocate is None:
- raise TypeError("Missing 'disk_should_deallocate' argument")
- if network_should_deallocate is None and 'networkShouldDeallocate' in kwargs:
- network_should_deallocate = kwargs['networkShouldDeallocate']
- if network_should_deallocate is None:
- raise TypeError("Missing 'network_should_deallocate' argument")
- if public_ip_should_deallocate is None and 'publicIpShouldDeallocate' in kwargs:
- public_ip_should_deallocate = kwargs['publicIpShouldDeallocate']
- if public_ip_should_deallocate is None:
- raise TypeError("Missing 'public_ip_should_deallocate' argument")
- if should_terminate_vm is None and 'shouldTerminateVm' in kwargs:
- should_terminate_vm = kwargs['shouldTerminateVm']
- if should_terminate_vm is None:
- raise TypeError("Missing 'should_terminate_vm' argument")
- if snapshot_should_deallocate is None and 'snapshotShouldDeallocate' in kwargs:
- snapshot_should_deallocate = kwargs['snapshotShouldDeallocate']
- if snapshot_should_deallocate is None:
- raise TypeError("Missing 'snapshot_should_deallocate' argument")
- if disk_ttl_in_hours is None and 'diskTtlInHours' in kwargs:
- disk_ttl_in_hours = kwargs['diskTtlInHours']
- if network_ttl_in_hours is None and 'networkTtlInHours' in kwargs:
- network_ttl_in_hours = kwargs['networkTtlInHours']
- if public_ip_ttl_in_hours is None and 'publicIpTtlInHours' in kwargs:
- public_ip_ttl_in_hours = kwargs['publicIpTtlInHours']
- if snapshot_ttl_in_hours is None and 'snapshotTtlInHours' in kwargs:
- snapshot_ttl_in_hours = kwargs['snapshotTtlInHours']
-
- _setter("disk_should_deallocate", disk_should_deallocate)
- _setter("network_should_deallocate", network_should_deallocate)
- _setter("public_ip_should_deallocate", public_ip_should_deallocate)
- _setter("should_terminate_vm", should_terminate_vm)
- _setter("snapshot_should_deallocate", snapshot_should_deallocate)
+ pulumi.set(__self__, "disk_should_deallocate", disk_should_deallocate)
+ pulumi.set(__self__, "network_should_deallocate", network_should_deallocate)
+ pulumi.set(__self__, "public_ip_should_deallocate", public_ip_should_deallocate)
+ pulumi.set(__self__, "should_terminate_vm", should_terminate_vm)
+ pulumi.set(__self__, "snapshot_should_deallocate", snapshot_should_deallocate)
if disk_ttl_in_hours is not None:
- _setter("disk_ttl_in_hours", disk_ttl_in_hours)
+ pulumi.set(__self__, "disk_ttl_in_hours", disk_ttl_in_hours)
if network_ttl_in_hours is not None:
- _setter("network_ttl_in_hours", network_ttl_in_hours)
+ pulumi.set(__self__, "network_ttl_in_hours", network_ttl_in_hours)
if public_ip_ttl_in_hours is not None:
- _setter("public_ip_ttl_in_hours", public_ip_ttl_in_hours)
+ pulumi.set(__self__, "public_ip_ttl_in_hours", public_ip_ttl_in_hours)
if snapshot_ttl_in_hours is not None:
- _setter("snapshot_ttl_in_hours", snapshot_ttl_in_hours)
+ pulumi.set(__self__, "snapshot_ttl_in_hours", snapshot_ttl_in_hours)
@property
@pulumi.getter(name="diskShouldDeallocate")
@@ -1308,42 +902,11 @@ def __init__(__self__, *,
data_disk_resource_group_name: str,
should_deallocate: bool,
ttl_in_hours: Optional[int] = None):
- StatefulNodeAzureDetachDataDisk._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- data_disk_name=data_disk_name,
- data_disk_resource_group_name=data_disk_resource_group_name,
- should_deallocate=should_deallocate,
- ttl_in_hours=ttl_in_hours,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- data_disk_name: Optional[str] = None,
- data_disk_resource_group_name: Optional[str] = None,
- should_deallocate: Optional[bool] = None,
- ttl_in_hours: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if data_disk_name is None and 'dataDiskName' in kwargs:
- data_disk_name = kwargs['dataDiskName']
- if data_disk_name is None:
- raise TypeError("Missing 'data_disk_name' argument")
- if data_disk_resource_group_name is None and 'dataDiskResourceGroupName' in kwargs:
- data_disk_resource_group_name = kwargs['dataDiskResourceGroupName']
- if data_disk_resource_group_name is None:
- raise TypeError("Missing 'data_disk_resource_group_name' argument")
- if should_deallocate is None and 'shouldDeallocate' in kwargs:
- should_deallocate = kwargs['shouldDeallocate']
- if should_deallocate is None:
- raise TypeError("Missing 'should_deallocate' argument")
- if ttl_in_hours is None and 'ttlInHours' in kwargs:
- ttl_in_hours = kwargs['ttlInHours']
-
- _setter("data_disk_name", data_disk_name)
- _setter("data_disk_resource_group_name", data_disk_resource_group_name)
- _setter("should_deallocate", should_deallocate)
+ pulumi.set(__self__, "data_disk_name", data_disk_name)
+ pulumi.set(__self__, "data_disk_resource_group_name", data_disk_resource_group_name)
+ pulumi.set(__self__, "should_deallocate", should_deallocate)
if ttl_in_hours is not None:
- _setter("ttl_in_hours", ttl_in_hours)
+ pulumi.set(__self__, "ttl_in_hours", ttl_in_hours)
@property
@pulumi.getter(name="dataDiskName")
@@ -1399,56 +962,15 @@ def __init__(__self__, *,
type: str,
protected_settings: Optional[Mapping[str, Any]] = None,
public_settings: Optional[Mapping[str, Any]] = None):
- StatefulNodeAzureExtension._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- api_version=api_version,
- minor_version_auto_upgrade=minor_version_auto_upgrade,
- name=name,
- publisher=publisher,
- type=type,
- protected_settings=protected_settings,
- public_settings=public_settings,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- api_version: Optional[str] = None,
- minor_version_auto_upgrade: Optional[bool] = None,
- name: Optional[str] = None,
- publisher: Optional[str] = None,
- type: Optional[str] = None,
- protected_settings: Optional[Mapping[str, Any]] = None,
- public_settings: Optional[Mapping[str, Any]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if api_version is None and 'apiVersion' in kwargs:
- api_version = kwargs['apiVersion']
- if api_version is None:
- raise TypeError("Missing 'api_version' argument")
- if minor_version_auto_upgrade is None and 'minorVersionAutoUpgrade' in kwargs:
- minor_version_auto_upgrade = kwargs['minorVersionAutoUpgrade']
- if minor_version_auto_upgrade is None:
- raise TypeError("Missing 'minor_version_auto_upgrade' argument")
- if name is None:
- raise TypeError("Missing 'name' argument")
- if publisher is None:
- raise TypeError("Missing 'publisher' argument")
- if type is None:
- raise TypeError("Missing 'type' argument")
- if protected_settings is None and 'protectedSettings' in kwargs:
- protected_settings = kwargs['protectedSettings']
- if public_settings is None and 'publicSettings' in kwargs:
- public_settings = kwargs['publicSettings']
-
- _setter("api_version", api_version)
- _setter("minor_version_auto_upgrade", minor_version_auto_upgrade)
- _setter("name", name)
- _setter("publisher", publisher)
- _setter("type", type)
+ pulumi.set(__self__, "api_version", api_version)
+ pulumi.set(__self__, "minor_version_auto_upgrade", minor_version_auto_upgrade)
+ pulumi.set(__self__, "name", name)
+ pulumi.set(__self__, "publisher", publisher)
+ pulumi.set(__self__, "type", type)
if protected_settings is not None:
- _setter("protected_settings", protected_settings)
+ pulumi.set(__self__, "protected_settings", protected_settings)
if public_settings is not None:
- _setter("public_settings", public_settings)
+ pulumi.set(__self__, "public_settings", public_settings)
@property
@pulumi.getter(name="apiVersion")
@@ -1516,41 +1038,12 @@ def __init__(__self__, *,
health_check_types: Sequence[str],
grace_period: Optional[int] = None,
unhealthy_duration: Optional[int] = None):
- StatefulNodeAzureHealth._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- auto_healing=auto_healing,
- health_check_types=health_check_types,
- grace_period=grace_period,
- unhealthy_duration=unhealthy_duration,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- auto_healing: Optional[bool] = None,
- health_check_types: Optional[Sequence[str]] = None,
- grace_period: Optional[int] = None,
- unhealthy_duration: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if auto_healing is None and 'autoHealing' in kwargs:
- auto_healing = kwargs['autoHealing']
- if auto_healing is None:
- raise TypeError("Missing 'auto_healing' argument")
- if health_check_types is None and 'healthCheckTypes' in kwargs:
- health_check_types = kwargs['healthCheckTypes']
- if health_check_types is None:
- raise TypeError("Missing 'health_check_types' argument")
- if grace_period is None and 'gracePeriod' in kwargs:
- grace_period = kwargs['gracePeriod']
- if unhealthy_duration is None and 'unhealthyDuration' in kwargs:
- unhealthy_duration = kwargs['unhealthyDuration']
-
- _setter("auto_healing", auto_healing)
- _setter("health_check_types", health_check_types)
+ pulumi.set(__self__, "auto_healing", auto_healing)
+ pulumi.set(__self__, "health_check_types", health_check_types)
if grace_period is not None:
- _setter("grace_period", grace_period)
+ pulumi.set(__self__, "grace_period", grace_period)
if unhealthy_duration is not None:
- _setter("unhealthy_duration", unhealthy_duration)
+ pulumi.set(__self__, "unhealthy_duration", unhealthy_duration)
@property
@pulumi.getter(name="autoHealing")
@@ -1598,31 +1091,12 @@ def __init__(__self__, *,
custom_images: Optional[Sequence['outputs.StatefulNodeAzureImageCustomImage']] = None,
galleries: Optional[Sequence['outputs.StatefulNodeAzureImageGallery']] = None,
marketplace_images: Optional[Sequence['outputs.StatefulNodeAzureImageMarketplaceImage']] = None):
- StatefulNodeAzureImage._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- custom_images=custom_images,
- galleries=galleries,
- marketplace_images=marketplace_images,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- custom_images: Optional[Sequence['outputs.StatefulNodeAzureImageCustomImage']] = None,
- galleries: Optional[Sequence['outputs.StatefulNodeAzureImageGallery']] = None,
- marketplace_images: Optional[Sequence['outputs.StatefulNodeAzureImageMarketplaceImage']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if custom_images is None and 'customImages' in kwargs:
- custom_images = kwargs['customImages']
- if marketplace_images is None and 'marketplaceImages' in kwargs:
- marketplace_images = kwargs['marketplaceImages']
-
if custom_images is not None:
- _setter("custom_images", custom_images)
+ pulumi.set(__self__, "custom_images", custom_images)
if galleries is not None:
- _setter("galleries", galleries)
+ pulumi.set(__self__, "galleries", galleries)
if marketplace_images is not None:
- _setter("marketplace_images", marketplace_images)
+ pulumi.set(__self__, "marketplace_images", marketplace_images)
@property
@pulumi.getter(name="customImages")
@@ -1662,27 +1136,8 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
custom_image_resource_group_name: str,
name: str):
- StatefulNodeAzureImageCustomImage._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- custom_image_resource_group_name=custom_image_resource_group_name,
- name=name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- custom_image_resource_group_name: Optional[str] = None,
- name: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if custom_image_resource_group_name is None and 'customImageResourceGroupName' in kwargs:
- custom_image_resource_group_name = kwargs['customImageResourceGroupName']
- if custom_image_resource_group_name is None:
- raise TypeError("Missing 'custom_image_resource_group_name' argument")
- if name is None:
- raise TypeError("Missing 'name' argument")
-
- _setter("custom_image_resource_group_name", custom_image_resource_group_name)
- _setter("name", name)
+ pulumi.set(__self__, "custom_image_resource_group_name", custom_image_resource_group_name)
+ pulumi.set(__self__, "name", name)
@property
@pulumi.getter(name="customImageResourceGroupName")
@@ -1725,43 +1180,10 @@ def __init__(__self__, *,
gallery_resource_group_name: str,
image_name: str,
version_name: str):
- StatefulNodeAzureImageGallery._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- gallery_name=gallery_name,
- gallery_resource_group_name=gallery_resource_group_name,
- image_name=image_name,
- version_name=version_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- gallery_name: Optional[str] = None,
- gallery_resource_group_name: Optional[str] = None,
- image_name: Optional[str] = None,
- version_name: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if gallery_name is None and 'galleryName' in kwargs:
- gallery_name = kwargs['galleryName']
- if gallery_name is None:
- raise TypeError("Missing 'gallery_name' argument")
- if gallery_resource_group_name is None and 'galleryResourceGroupName' in kwargs:
- gallery_resource_group_name = kwargs['galleryResourceGroupName']
- if gallery_resource_group_name is None:
- raise TypeError("Missing 'gallery_resource_group_name' argument")
- if image_name is None and 'imageName' in kwargs:
- image_name = kwargs['imageName']
- if image_name is None:
- raise TypeError("Missing 'image_name' argument")
- if version_name is None and 'versionName' in kwargs:
- version_name = kwargs['versionName']
- if version_name is None:
- raise TypeError("Missing 'version_name' argument")
-
- _setter("gallery_name", gallery_name)
- _setter("gallery_resource_group_name", gallery_resource_group_name)
- _setter("image_name", image_name)
- _setter("version_name", version_name)
+ pulumi.set(__self__, "gallery_name", gallery_name)
+ pulumi.set(__self__, "gallery_resource_group_name", gallery_resource_group_name)
+ pulumi.set(__self__, "image_name", image_name)
+ pulumi.set(__self__, "version_name", version_name)
@property
@pulumi.getter(name="galleryName")
@@ -1791,35 +1213,10 @@ def __init__(__self__, *,
publisher: str,
sku: str,
version: str):
- StatefulNodeAzureImageMarketplaceImage._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- offer=offer,
- publisher=publisher,
- sku=sku,
- version=version,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- offer: Optional[str] = None,
- publisher: Optional[str] = None,
- sku: Optional[str] = None,
- version: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if offer is None:
- raise TypeError("Missing 'offer' argument")
- if publisher is None:
- raise TypeError("Missing 'publisher' argument")
- if sku is None:
- raise TypeError("Missing 'sku' argument")
- if version is None:
- raise TypeError("Missing 'version' argument")
-
- _setter("offer", offer)
- _setter("publisher", publisher)
- _setter("sku", sku)
- _setter("version", version)
+ pulumi.set(__self__, "offer", offer)
+ pulumi.set(__self__, "publisher", publisher)
+ pulumi.set(__self__, "sku", sku)
+ pulumi.set(__self__, "version", version)
@property
@pulumi.getter
@@ -1872,41 +1269,12 @@ def __init__(__self__, *,
resource_group_name: str,
draining_timeout: Optional[int] = None,
resources_retention_time: Optional[int] = None):
- StatefulNodeAzureImportVm._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- original_vm_name=original_vm_name,
- resource_group_name=resource_group_name,
- draining_timeout=draining_timeout,
- resources_retention_time=resources_retention_time,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- original_vm_name: Optional[str] = None,
- resource_group_name: Optional[str] = None,
- draining_timeout: Optional[int] = None,
- resources_retention_time: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if original_vm_name is None and 'originalVmName' in kwargs:
- original_vm_name = kwargs['originalVmName']
- if original_vm_name is None:
- raise TypeError("Missing 'original_vm_name' argument")
- if resource_group_name is None and 'resourceGroupName' in kwargs:
- resource_group_name = kwargs['resourceGroupName']
- if resource_group_name is None:
- raise TypeError("Missing 'resource_group_name' argument")
- if draining_timeout is None and 'drainingTimeout' in kwargs:
- draining_timeout = kwargs['drainingTimeout']
- if resources_retention_time is None and 'resourcesRetentionTime' in kwargs:
- resources_retention_time = kwargs['resourcesRetentionTime']
-
- _setter("original_vm_name", original_vm_name)
- _setter("resource_group_name", resource_group_name)
+ pulumi.set(__self__, "original_vm_name", original_vm_name)
+ pulumi.set(__self__, "resource_group_name", resource_group_name)
if draining_timeout is not None:
- _setter("draining_timeout", draining_timeout)
+ pulumi.set(__self__, "draining_timeout", draining_timeout)
if resources_retention_time is not None:
- _setter("resources_retention_time", resources_retention_time)
+ pulumi.set(__self__, "resources_retention_time", resources_retention_time)
@property
@pulumi.getter(name="originalVmName")
@@ -1956,43 +1324,12 @@ def __init__(__self__, *,
resource_group_name: str,
type: str,
sku: Optional[str] = None):
- StatefulNodeAzureLoadBalancer._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- backend_pool_names=backend_pool_names,
- name=name,
- resource_group_name=resource_group_name,
- type=type,
- sku=sku,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- backend_pool_names: Optional[Sequence[str]] = None,
- name: Optional[str] = None,
- resource_group_name: Optional[str] = None,
- type: Optional[str] = None,
- sku: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if backend_pool_names is None and 'backendPoolNames' in kwargs:
- backend_pool_names = kwargs['backendPoolNames']
- if backend_pool_names is None:
- raise TypeError("Missing 'backend_pool_names' argument")
- if name is None:
- raise TypeError("Missing 'name' argument")
- if resource_group_name is None and 'resourceGroupName' in kwargs:
- resource_group_name = kwargs['resourceGroupName']
- if resource_group_name is None:
- raise TypeError("Missing 'resource_group_name' argument")
- if type is None:
- raise TypeError("Missing 'type' argument")
-
- _setter("backend_pool_names", backend_pool_names)
- _setter("name", name)
- _setter("resource_group_name", resource_group_name)
- _setter("type", type)
+ pulumi.set(__self__, "backend_pool_names", backend_pool_names)
+ pulumi.set(__self__, "name", name)
+ pulumi.set(__self__, "resource_group_name", resource_group_name)
+ pulumi.set(__self__, "type", type)
if sku is not None:
- _setter("sku", sku)
+ pulumi.set(__self__, "sku", sku)
@property
@pulumi.getter(name="backendPoolNames")
@@ -2045,32 +1382,11 @@ def __init__(__self__, *,
user_name: str,
password: Optional[str] = None,
ssh_public_key: Optional[str] = None):
- StatefulNodeAzureLogin._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- user_name=user_name,
- password=password,
- ssh_public_key=ssh_public_key,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- user_name: Optional[str] = None,
- password: Optional[str] = None,
- ssh_public_key: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if user_name is None and 'userName' in kwargs:
- user_name = kwargs['userName']
- if user_name is None:
- raise TypeError("Missing 'user_name' argument")
- if ssh_public_key is None and 'sshPublicKey' in kwargs:
- ssh_public_key = kwargs['sshPublicKey']
-
- _setter("user_name", user_name)
+ pulumi.set(__self__, "user_name", user_name)
if password is not None:
- _setter("password", password)
+ pulumi.set(__self__, "password", password)
if ssh_public_key is not None:
- _setter("ssh_public_key", ssh_public_key)
+ pulumi.set(__self__, "ssh_public_key", ssh_public_key)
@property
@pulumi.getter(name="userName")
@@ -2110,27 +1426,8 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
name: str,
resource_group_name: str):
- StatefulNodeAzureManagedServiceIdentity._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- resource_group_name=resource_group_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[str] = None,
- resource_group_name: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
- if resource_group_name is None and 'resourceGroupName' in kwargs:
- resource_group_name = kwargs['resourceGroupName']
- if resource_group_name is None:
- raise TypeError("Missing 'resource_group_name' argument")
-
- _setter("name", name)
- _setter("resource_group_name", resource_group_name)
+ pulumi.set(__self__, "name", name)
+ pulumi.set(__self__, "resource_group_name", resource_group_name)
@property
@pulumi.getter
@@ -2170,36 +1467,9 @@ def __init__(__self__, *,
network_interfaces: Sequence['outputs.StatefulNodeAzureNetworkNetworkInterface'],
network_resource_group_name: str,
virtual_network_name: str):
- StatefulNodeAzureNetwork._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- network_interfaces=network_interfaces,
- network_resource_group_name=network_resource_group_name,
- virtual_network_name=virtual_network_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- network_interfaces: Optional[Sequence['outputs.StatefulNodeAzureNetworkNetworkInterface']] = None,
- network_resource_group_name: Optional[str] = None,
- virtual_network_name: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if network_interfaces is None and 'networkInterfaces' in kwargs:
- network_interfaces = kwargs['networkInterfaces']
- if network_interfaces is None:
- raise TypeError("Missing 'network_interfaces' argument")
- if network_resource_group_name is None and 'networkResourceGroupName' in kwargs:
- network_resource_group_name = kwargs['networkResourceGroupName']
- if network_resource_group_name is None:
- raise TypeError("Missing 'network_resource_group_name' argument")
- if virtual_network_name is None and 'virtualNetworkName' in kwargs:
- virtual_network_name = kwargs['virtualNetworkName']
- if virtual_network_name is None:
- raise TypeError("Missing 'virtual_network_name' argument")
-
- _setter("network_interfaces", network_interfaces)
- _setter("network_resource_group_name", network_resource_group_name)
- _setter("virtual_network_name", virtual_network_name)
+ pulumi.set(__self__, "network_interfaces", network_interfaces)
+ pulumi.set(__self__, "network_resource_group_name", network_resource_group_name)
+ pulumi.set(__self__, "virtual_network_name", virtual_network_name)
@property
@pulumi.getter(name="networkInterfaces")
@@ -2265,77 +1535,24 @@ def __init__(__self__, *,
private_ip_addresses: Optional[Sequence[str]] = None,
public_ip_sku: Optional[str] = None,
public_ips: Optional[Sequence['outputs.StatefulNodeAzureNetworkNetworkInterfacePublicIp']] = None):
- StatefulNodeAzureNetworkNetworkInterface._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- is_primary=is_primary,
- subnet_name=subnet_name,
- additional_ip_configurations=additional_ip_configurations,
- application_security_groups=application_security_groups,
- assign_public_ip=assign_public_ip,
- enable_ip_forwarding=enable_ip_forwarding,
- network_security_groups=network_security_groups,
- private_ip_addresses=private_ip_addresses,
- public_ip_sku=public_ip_sku,
- public_ips=public_ips,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- is_primary: Optional[bool] = None,
- subnet_name: Optional[str] = None,
- additional_ip_configurations: Optional[Sequence['outputs.StatefulNodeAzureNetworkNetworkInterfaceAdditionalIpConfiguration']] = None,
- application_security_groups: Optional[Sequence['outputs.StatefulNodeAzureNetworkNetworkInterfaceApplicationSecurityGroup']] = None,
- assign_public_ip: Optional[bool] = None,
- enable_ip_forwarding: Optional[bool] = None,
- network_security_groups: Optional[Sequence['outputs.StatefulNodeAzureNetworkNetworkInterfaceNetworkSecurityGroup']] = None,
- private_ip_addresses: Optional[Sequence[str]] = None,
- public_ip_sku: Optional[str] = None,
- public_ips: Optional[Sequence['outputs.StatefulNodeAzureNetworkNetworkInterfacePublicIp']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if is_primary is None and 'isPrimary' in kwargs:
- is_primary = kwargs['isPrimary']
- if is_primary is None:
- raise TypeError("Missing 'is_primary' argument")
- if subnet_name is None and 'subnetName' in kwargs:
- subnet_name = kwargs['subnetName']
- if subnet_name is None:
- raise TypeError("Missing 'subnet_name' argument")
- if additional_ip_configurations is None and 'additionalIpConfigurations' in kwargs:
- additional_ip_configurations = kwargs['additionalIpConfigurations']
- if application_security_groups is None and 'applicationSecurityGroups' in kwargs:
- application_security_groups = kwargs['applicationSecurityGroups']
- if assign_public_ip is None and 'assignPublicIp' in kwargs:
- assign_public_ip = kwargs['assignPublicIp']
- if enable_ip_forwarding is None and 'enableIpForwarding' in kwargs:
- enable_ip_forwarding = kwargs['enableIpForwarding']
- if network_security_groups is None and 'networkSecurityGroups' in kwargs:
- network_security_groups = kwargs['networkSecurityGroups']
- if private_ip_addresses is None and 'privateIpAddresses' in kwargs:
- private_ip_addresses = kwargs['privateIpAddresses']
- if public_ip_sku is None and 'publicIpSku' in kwargs:
- public_ip_sku = kwargs['publicIpSku']
- if public_ips is None and 'publicIps' in kwargs:
- public_ips = kwargs['publicIps']
-
- _setter("is_primary", is_primary)
- _setter("subnet_name", subnet_name)
+ pulumi.set(__self__, "is_primary", is_primary)
+ pulumi.set(__self__, "subnet_name", subnet_name)
if additional_ip_configurations is not None:
- _setter("additional_ip_configurations", additional_ip_configurations)
+ pulumi.set(__self__, "additional_ip_configurations", additional_ip_configurations)
if application_security_groups is not None:
- _setter("application_security_groups", application_security_groups)
+ pulumi.set(__self__, "application_security_groups", application_security_groups)
if assign_public_ip is not None:
- _setter("assign_public_ip", assign_public_ip)
+ pulumi.set(__self__, "assign_public_ip", assign_public_ip)
if enable_ip_forwarding is not None:
- _setter("enable_ip_forwarding", enable_ip_forwarding)
+ pulumi.set(__self__, "enable_ip_forwarding", enable_ip_forwarding)
if network_security_groups is not None:
- _setter("network_security_groups", network_security_groups)
+ pulumi.set(__self__, "network_security_groups", network_security_groups)
if private_ip_addresses is not None:
- _setter("private_ip_addresses", private_ip_addresses)
+ pulumi.set(__self__, "private_ip_addresses", private_ip_addresses)
if public_ip_sku is not None:
- _setter("public_ip_sku", public_ip_sku)
+ pulumi.set(__self__, "public_ip_sku", public_ip_sku)
if public_ips is not None:
- _setter("public_ips", public_ips)
+ pulumi.set(__self__, "public_ips", public_ips)
@property
@pulumi.getter(name="isPrimary")
@@ -2410,27 +1627,8 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
name: str,
private_ip_address_version: str):
- StatefulNodeAzureNetworkNetworkInterfaceAdditionalIpConfiguration._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- private_ip_address_version=private_ip_address_version,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[str] = None,
- private_ip_address_version: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
- if private_ip_address_version is None and 'privateIpAddressVersion' in kwargs:
- private_ip_address_version = kwargs['privateIpAddressVersion']
- if private_ip_address_version is None:
- raise TypeError("Missing 'private_ip_address_version' argument")
-
- _setter("name", name)
- _setter("private_ip_address_version", private_ip_address_version)
+ pulumi.set(__self__, "name", name)
+ pulumi.set(__self__, "private_ip_address_version", private_ip_address_version)
@property
@pulumi.getter
@@ -2465,27 +1663,8 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
name: str,
network_resource_group_name: str):
- StatefulNodeAzureNetworkNetworkInterfaceApplicationSecurityGroup._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- network_resource_group_name=network_resource_group_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[str] = None,
- network_resource_group_name: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
- if network_resource_group_name is None and 'networkResourceGroupName' in kwargs:
- network_resource_group_name = kwargs['networkResourceGroupName']
- if network_resource_group_name is None:
- raise TypeError("Missing 'network_resource_group_name' argument")
-
- _setter("name", name)
- _setter("network_resource_group_name", network_resource_group_name)
+ pulumi.set(__self__, "name", name)
+ pulumi.set(__self__, "network_resource_group_name", network_resource_group_name)
@property
@pulumi.getter
@@ -2520,25 +1699,10 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
name: Optional[str] = None,
network_resource_group_name: Optional[str] = None):
- StatefulNodeAzureNetworkNetworkInterfaceNetworkSecurityGroup._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- network_resource_group_name=network_resource_group_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[str] = None,
- network_resource_group_name: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if network_resource_group_name is None and 'networkResourceGroupName' in kwargs:
- network_resource_group_name = kwargs['networkResourceGroupName']
-
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if network_resource_group_name is not None:
- _setter("network_resource_group_name", network_resource_group_name)
+ pulumi.set(__self__, "network_resource_group_name", network_resource_group_name)
@property
@pulumi.getter
@@ -2573,27 +1737,8 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
name: str,
network_resource_group_name: str):
- StatefulNodeAzureNetworkNetworkInterfacePublicIp._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- network_resource_group_name=network_resource_group_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[str] = None,
- network_resource_group_name: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
- if network_resource_group_name is None and 'networkResourceGroupName' in kwargs:
- network_resource_group_name = kwargs['networkResourceGroupName']
- if network_resource_group_name is None:
- raise TypeError("Missing 'network_resource_group_name' argument")
-
- _setter("name", name)
- _setter("network_resource_group_name", network_resource_group_name)
+ pulumi.set(__self__, "name", name)
+ pulumi.set(__self__, "network_resource_group_name", network_resource_group_name)
@property
@pulumi.getter
@@ -2628,26 +1773,9 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
type: str,
size_gb: Optional[int] = None):
- StatefulNodeAzureOsDisk._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- type=type,
- size_gb=size_gb,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- type: Optional[str] = None,
- size_gb: Optional[int] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if type is None:
- raise TypeError("Missing 'type' argument")
- if size_gb is None and 'sizeGb' in kwargs:
- size_gb = kwargs['sizeGb']
-
- _setter("type", type)
+ pulumi.set(__self__, "type", type)
if size_gb is not None:
- _setter("size_gb", size_gb)
+ pulumi.set(__self__, "size_gb", size_gb)
@property
@pulumi.getter
@@ -2685,34 +1813,9 @@ def __init__(__self__, *,
cron_expression: str,
is_enabled: bool,
type: str):
- StatefulNodeAzureSchedulingTask._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- cron_expression=cron_expression,
- is_enabled=is_enabled,
- type=type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- cron_expression: Optional[str] = None,
- is_enabled: Optional[bool] = None,
- type: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if cron_expression is None and 'cronExpression' in kwargs:
- cron_expression = kwargs['cronExpression']
- if cron_expression is None:
- raise TypeError("Missing 'cron_expression' argument")
- if is_enabled is None and 'isEnabled' in kwargs:
- is_enabled = kwargs['isEnabled']
- if is_enabled is None:
- raise TypeError("Missing 'is_enabled' argument")
- if type is None:
- raise TypeError("Missing 'type' argument")
-
- _setter("cron_expression", cron_expression)
- _setter("is_enabled", is_enabled)
- _setter("type", type)
+ pulumi.set(__self__, "cron_expression", cron_expression)
+ pulumi.set(__self__, "is_enabled", is_enabled)
+ pulumi.set(__self__, "type", type)
@property
@pulumi.getter(name="cronExpression")
@@ -2754,29 +1857,8 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
source_vaults: Sequence['outputs.StatefulNodeAzureSecretSourceVault'],
vault_certificates: Sequence['outputs.StatefulNodeAzureSecretVaultCertificate']):
- StatefulNodeAzureSecret._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- source_vaults=source_vaults,
- vault_certificates=vault_certificates,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- source_vaults: Optional[Sequence['outputs.StatefulNodeAzureSecretSourceVault']] = None,
- vault_certificates: Optional[Sequence['outputs.StatefulNodeAzureSecretVaultCertificate']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if source_vaults is None and 'sourceVaults' in kwargs:
- source_vaults = kwargs['sourceVaults']
- if source_vaults is None:
- raise TypeError("Missing 'source_vaults' argument")
- if vault_certificates is None and 'vaultCertificates' in kwargs:
- vault_certificates = kwargs['vaultCertificates']
- if vault_certificates is None:
- raise TypeError("Missing 'vault_certificates' argument")
-
- _setter("source_vaults", source_vaults)
- _setter("vault_certificates", vault_certificates)
+ pulumi.set(__self__, "source_vaults", source_vaults)
+ pulumi.set(__self__, "vault_certificates", vault_certificates)
@property
@pulumi.getter(name="sourceVaults")
@@ -2811,27 +1893,8 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
name: str,
resource_group_name: str):
- StatefulNodeAzureSecretSourceVault._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- name=name,
- resource_group_name=resource_group_name,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- name: Optional[str] = None,
- resource_group_name: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if name is None:
- raise TypeError("Missing 'name' argument")
- if resource_group_name is None and 'resourceGroupName' in kwargs:
- resource_group_name = kwargs['resourceGroupName']
- if resource_group_name is None:
- raise TypeError("Missing 'resource_group_name' argument")
-
- _setter("name", name)
- _setter("resource_group_name", resource_group_name)
+ pulumi.set(__self__, "name", name)
+ pulumi.set(__self__, "resource_group_name", resource_group_name)
@property
@pulumi.getter
@@ -2868,27 +1931,10 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
certificate_store: Optional[str] = None,
certificate_url: Optional[str] = None):
- StatefulNodeAzureSecretVaultCertificate._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- certificate_store=certificate_store,
- certificate_url=certificate_url,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- certificate_store: Optional[str] = None,
- certificate_url: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if certificate_store is None and 'certificateStore' in kwargs:
- certificate_store = kwargs['certificateStore']
- if certificate_url is None and 'certificateUrl' in kwargs:
- certificate_url = kwargs['certificateUrl']
-
if certificate_store is not None:
- _setter("certificate_store", certificate_store)
+ pulumi.set(__self__, "certificate_store", certificate_store)
if certificate_url is not None:
- _setter("certificate_url", certificate_url)
+ pulumi.set(__self__, "certificate_url", certificate_url)
@property
@pulumi.getter(name="certificateStore")
@@ -2928,33 +1974,12 @@ def __init__(__self__, *,
secure_boot_enabled: Optional[bool] = None,
security_type: Optional[str] = None,
vtpm_enabled: Optional[bool] = None):
- StatefulNodeAzureSecurity._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- secure_boot_enabled=secure_boot_enabled,
- security_type=security_type,
- vtpm_enabled=vtpm_enabled,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- secure_boot_enabled: Optional[bool] = None,
- security_type: Optional[str] = None,
- vtpm_enabled: Optional[bool] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if secure_boot_enabled is None and 'secureBootEnabled' in kwargs:
- secure_boot_enabled = kwargs['secureBootEnabled']
- if security_type is None and 'securityType' in kwargs:
- security_type = kwargs['securityType']
- if vtpm_enabled is None and 'vtpmEnabled' in kwargs:
- vtpm_enabled = kwargs['vtpmEnabled']
-
if secure_boot_enabled is not None:
- _setter("secure_boot_enabled", secure_boot_enabled)
+ pulumi.set(__self__, "secure_boot_enabled", secure_boot_enabled)
if security_type is not None:
- _setter("security_type", security_type)
+ pulumi.set(__self__, "security_type", security_type)
if vtpm_enabled is not None:
- _setter("vtpm_enabled", vtpm_enabled)
+ pulumi.set(__self__, "vtpm_enabled", vtpm_enabled)
@property
@pulumi.getter(name="secureBootEnabled")
@@ -2977,25 +2002,8 @@ class StatefulNodeAzureSignal(dict):
def __init__(__self__, *,
timeout: int,
type: str):
- StatefulNodeAzureSignal._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- timeout=timeout,
- type=type,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- timeout: Optional[int] = None,
- type: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if timeout is None:
- raise TypeError("Missing 'timeout' argument")
- if type is None:
- raise TypeError("Missing 'type' argument")
-
- _setter("timeout", timeout)
- _setter("type", type)
+ pulumi.set(__self__, "timeout", timeout)
+ pulumi.set(__self__, "type", type)
@property
@pulumi.getter
@@ -3044,52 +2052,17 @@ def __init__(__self__, *,
optimization_windows: Optional[Sequence[str]] = None,
preferred_life_cycle: Optional[str] = None,
revert_to_spot: Optional['outputs.StatefulNodeAzureStrategyRevertToSpot'] = None):
- StatefulNodeAzureStrategy._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- fallback_to_on_demand=fallback_to_on_demand,
- capacity_reservations=capacity_reservations,
- draining_timeout=draining_timeout,
- optimization_windows=optimization_windows,
- preferred_life_cycle=preferred_life_cycle,
- revert_to_spot=revert_to_spot,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- fallback_to_on_demand: Optional[bool] = None,
- capacity_reservations: Optional[Sequence['outputs.StatefulNodeAzureStrategyCapacityReservation']] = None,
- draining_timeout: Optional[int] = None,
- optimization_windows: Optional[Sequence[str]] = None,
- preferred_life_cycle: Optional[str] = None,
- revert_to_spot: Optional['outputs.StatefulNodeAzureStrategyRevertToSpot'] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if fallback_to_on_demand is None and 'fallbackToOnDemand' in kwargs:
- fallback_to_on_demand = kwargs['fallbackToOnDemand']
- if fallback_to_on_demand is None:
- raise TypeError("Missing 'fallback_to_on_demand' argument")
- if capacity_reservations is None and 'capacityReservations' in kwargs:
- capacity_reservations = kwargs['capacityReservations']
- if draining_timeout is None and 'drainingTimeout' in kwargs:
- draining_timeout = kwargs['drainingTimeout']
- if optimization_windows is None and 'optimizationWindows' in kwargs:
- optimization_windows = kwargs['optimizationWindows']
- if preferred_life_cycle is None and 'preferredLifeCycle' in kwargs:
- preferred_life_cycle = kwargs['preferredLifeCycle']
- if revert_to_spot is None and 'revertToSpot' in kwargs:
- revert_to_spot = kwargs['revertToSpot']
-
- _setter("fallback_to_on_demand", fallback_to_on_demand)
+ pulumi.set(__self__, "fallback_to_on_demand", fallback_to_on_demand)
if capacity_reservations is not None:
- _setter("capacity_reservations", capacity_reservations)
+ pulumi.set(__self__, "capacity_reservations", capacity_reservations)
if draining_timeout is not None:
- _setter("draining_timeout", draining_timeout)
+ pulumi.set(__self__, "draining_timeout", draining_timeout)
if optimization_windows is not None:
- _setter("optimization_windows", optimization_windows)
+ pulumi.set(__self__, "optimization_windows", optimization_windows)
if preferred_life_cycle is not None:
- _setter("preferred_life_cycle", preferred_life_cycle)
+ pulumi.set(__self__, "preferred_life_cycle", preferred_life_cycle)
if revert_to_spot is not None:
- _setter("revert_to_spot", revert_to_spot)
+ pulumi.set(__self__, "revert_to_spot", revert_to_spot)
@property
@pulumi.getter(name="fallbackToOnDemand")
@@ -3149,35 +2122,10 @@ def __init__(__self__, *,
should_utilize: bool,
utilization_strategy: str,
capacity_reservation_groups: Optional[Sequence['outputs.StatefulNodeAzureStrategyCapacityReservationCapacityReservationGroup']] = None):
- StatefulNodeAzureStrategyCapacityReservation._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- should_utilize=should_utilize,
- utilization_strategy=utilization_strategy,
- capacity_reservation_groups=capacity_reservation_groups,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- should_utilize: Optional[bool] = None,
- utilization_strategy: Optional[str] = None,
- capacity_reservation_groups: Optional[Sequence['outputs.StatefulNodeAzureStrategyCapacityReservationCapacityReservationGroup']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if should_utilize is None and 'shouldUtilize' in kwargs:
- should_utilize = kwargs['shouldUtilize']
- if should_utilize is None:
- raise TypeError("Missing 'should_utilize' argument")
- if utilization_strategy is None and 'utilizationStrategy' in kwargs:
- utilization_strategy = kwargs['utilizationStrategy']
- if utilization_strategy is None:
- raise TypeError("Missing 'utilization_strategy' argument")
- if capacity_reservation_groups is None and 'capacityReservationGroups' in kwargs:
- capacity_reservation_groups = kwargs['capacityReservationGroups']
-
- _setter("should_utilize", should_utilize)
- _setter("utilization_strategy", utilization_strategy)
+ pulumi.set(__self__, "should_utilize", should_utilize)
+ pulumi.set(__self__, "utilization_strategy", utilization_strategy)
if capacity_reservation_groups is not None:
- _setter("capacity_reservation_groups", capacity_reservation_groups)
+ pulumi.set(__self__, "capacity_reservation_groups", capacity_reservation_groups)
@property
@pulumi.getter(name="shouldUtilize")
@@ -3222,35 +2170,10 @@ def __init__(__self__, *,
crg_name: str,
crg_resource_group_name: str,
crg_should_prioritize: Optional[bool] = None):
- StatefulNodeAzureStrategyCapacityReservationCapacityReservationGroup._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- crg_name=crg_name,
- crg_resource_group_name=crg_resource_group_name,
- crg_should_prioritize=crg_should_prioritize,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- crg_name: Optional[str] = None,
- crg_resource_group_name: Optional[str] = None,
- crg_should_prioritize: Optional[bool] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if crg_name is None and 'crgName' in kwargs:
- crg_name = kwargs['crgName']
- if crg_name is None:
- raise TypeError("Missing 'crg_name' argument")
- if crg_resource_group_name is None and 'crgResourceGroupName' in kwargs:
- crg_resource_group_name = kwargs['crgResourceGroupName']
- if crg_resource_group_name is None:
- raise TypeError("Missing 'crg_resource_group_name' argument")
- if crg_should_prioritize is None and 'crgShouldPrioritize' in kwargs:
- crg_should_prioritize = kwargs['crgShouldPrioritize']
-
- _setter("crg_name", crg_name)
- _setter("crg_resource_group_name", crg_resource_group_name)
+ pulumi.set(__self__, "crg_name", crg_name)
+ pulumi.set(__self__, "crg_resource_group_name", crg_resource_group_name)
if crg_should_prioritize is not None:
- _setter("crg_should_prioritize", crg_should_prioritize)
+ pulumi.set(__self__, "crg_should_prioritize", crg_should_prioritize)
@property
@pulumi.getter(name="crgName")
@@ -3289,22 +2212,7 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
perform_at: str):
- StatefulNodeAzureStrategyRevertToSpot._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- perform_at=perform_at,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- perform_at: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if perform_at is None and 'performAt' in kwargs:
- perform_at = kwargs['performAt']
- if perform_at is None:
- raise TypeError("Missing 'perform_at' argument")
-
- _setter("perform_at", perform_at)
+ pulumi.set(__self__, "perform_at", perform_at)
@property
@pulumi.getter(name="performAt")
@@ -3336,28 +2244,9 @@ def get(self, key: str, default = None) -> Any:
def __init__(__self__, *,
tag_key: str,
tag_value: Optional[str] = None):
- StatefulNodeAzureTag._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- tag_key=tag_key,
- tag_value=tag_value,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- tag_key: Optional[str] = None,
- tag_value: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if tag_key is None and 'tagKey' in kwargs:
- tag_key = kwargs['tagKey']
- if tag_key is None:
- raise TypeError("Missing 'tag_key' argument")
- if tag_value is None and 'tagValue' in kwargs:
- tag_value = kwargs['tagValue']
-
- _setter("tag_key", tag_key)
+ pulumi.set(__self__, "tag_key", tag_key)
if tag_value is not None:
- _setter("tag_value", tag_value)
+ pulumi.set(__self__, "tag_value", tag_value)
@property
@pulumi.getter(name="tagKey")
@@ -3374,20 +2263,7 @@ def tag_value(self) -> Optional[str]:
class StatefulNodeAzureUpdateState(dict):
def __init__(__self__, *,
state: str):
- StatefulNodeAzureUpdateState._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- state=state,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- state: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if state is None:
- raise TypeError("Missing 'state' argument")
-
- _setter("state", state)
+ pulumi.set(__self__, "state", state)
@property
@pulumi.getter
diff --git a/sdk/python/pulumi_spotinst/provider.py b/sdk/python/pulumi_spotinst/provider.py
index 7ee12c64..2d0e0419 100644
--- a/sdk/python/pulumi_spotinst/provider.py
+++ b/sdk/python/pulumi_spotinst/provider.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from . import _utilities
__all__ = ['ProviderArgs', 'Provider']
@@ -23,29 +23,12 @@ def __init__(__self__, *,
:param pulumi.Input[str] feature_flags: Spotinst SDK Feature Flags
:param pulumi.Input[str] token: Spotinst Personal API Access Token
"""
- ProviderArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- account=account,
- feature_flags=feature_flags,
- token=token,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- account: Optional[pulumi.Input[str]] = None,
- feature_flags: Optional[pulumi.Input[str]] = None,
- token: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if feature_flags is None and 'featureFlags' in kwargs:
- feature_flags = kwargs['featureFlags']
-
if account is not None:
- _setter("account", account)
+ pulumi.set(__self__, "account", account)
if feature_flags is not None:
- _setter("feature_flags", feature_flags)
+ pulumi.set(__self__, "feature_flags", feature_flags)
if token is not None:
- _setter("token", token)
+ pulumi.set(__self__, "token", token)
@property
@pulumi.getter
@@ -127,10 +110,6 @@ def __init__(__self__, resource_name: str, *args, **kwargs):
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
- kwargs = kwargs or {}
- def _setter(key, value):
- kwargs[key] = value
- ProviderArgs._configure(_setter, **kwargs)
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
diff --git a/sdk/python/pulumi_spotinst/spark/_inputs.py b/sdk/python/pulumi_spotinst/spark/_inputs.py
index ff62bd0c..b3701d61 100644
--- a/sdk/python/pulumi_spotinst/spark/_inputs.py
+++ b/sdk/python/pulumi_spotinst/spark/_inputs.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
__all__ = [
@@ -30,27 +30,10 @@ def __init__(__self__, *,
:param pulumi.Input[bool] create_vngs: - Enable/disable the creation of Ocean Spark VNGs during cluster creation.
:param pulumi.Input[bool] use_taints: - Enable/disable Ocean Spark taints on the Ocean Spark VNGs. By default, Ocean Spark uses taints to prevent non-Spark workloads from running on Ocean Spark VNGs.
"""
- OceanComputeArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- create_vngs=create_vngs,
- use_taints=use_taints,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- create_vngs: Optional[pulumi.Input[bool]] = None,
- use_taints: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if create_vngs is None and 'createVngs' in kwargs:
- create_vngs = kwargs['createVngs']
- if use_taints is None and 'useTaints' in kwargs:
- use_taints = kwargs['useTaints']
-
if create_vngs is not None:
- _setter("create_vngs", create_vngs)
+ pulumi.set(__self__, "create_vngs", create_vngs)
if use_taints is not None:
- _setter("use_taints", use_taints)
+ pulumi.set(__self__, "use_taints", use_taints)
@property
@pulumi.getter(name="createVngs")
@@ -88,43 +71,16 @@ def __init__(__self__, *,
"""
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] service_annotations: - **DEPRECATED**: Use `load_balancer.service_annotations` instead.
"""
- OceanIngressArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- controller=controller,
- custom_endpoint=custom_endpoint,
- load_balancer=load_balancer,
- private_link=private_link,
- service_annotations=service_annotations,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- controller: Optional[pulumi.Input['OceanIngressControllerArgs']] = None,
- custom_endpoint: Optional[pulumi.Input['OceanIngressCustomEndpointArgs']] = None,
- load_balancer: Optional[pulumi.Input['OceanIngressLoadBalancerArgs']] = None,
- private_link: Optional[pulumi.Input['OceanIngressPrivateLinkArgs']] = None,
- service_annotations: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if custom_endpoint is None and 'customEndpoint' in kwargs:
- custom_endpoint = kwargs['customEndpoint']
- if load_balancer is None and 'loadBalancer' in kwargs:
- load_balancer = kwargs['loadBalancer']
- if private_link is None and 'privateLink' in kwargs:
- private_link = kwargs['privateLink']
- if service_annotations is None and 'serviceAnnotations' in kwargs:
- service_annotations = kwargs['serviceAnnotations']
-
if controller is not None:
- _setter("controller", controller)
+ pulumi.set(__self__, "controller", controller)
if custom_endpoint is not None:
- _setter("custom_endpoint", custom_endpoint)
+ pulumi.set(__self__, "custom_endpoint", custom_endpoint)
if load_balancer is not None:
- _setter("load_balancer", load_balancer)
+ pulumi.set(__self__, "load_balancer", load_balancer)
if private_link is not None:
- _setter("private_link", private_link)
+ pulumi.set(__self__, "private_link", private_link)
if service_annotations is not None:
- _setter("service_annotations", service_annotations)
+ pulumi.set(__self__, "service_annotations", service_annotations)
@property
@pulumi.getter
@@ -182,19 +138,8 @@ def __init__(__self__, *,
"""
:param pulumi.Input[bool] managed: - Should an ingress controller managed by Ocean for Apache Spark be installed on the cluster.
"""
- OceanIngressControllerArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- managed=managed,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- managed: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if managed is not None:
- _setter("managed", managed)
+ pulumi.set(__self__, "managed", managed)
@property
@pulumi.getter
@@ -218,23 +163,10 @@ def __init__(__self__, *,
:param pulumi.Input[str] address: - The address the Ocean for Apache Spark control plane will use when addressing the cluster.
:param pulumi.Input[bool] enabled: - Should the Ocean for Apache Spark control plane address the cluster using a custom endpoint. Use this to specify the DNS address of an externally provisioned (unmanaged) load balancer.
"""
- OceanIngressCustomEndpointArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- address=address,
- enabled=enabled,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- address: Optional[pulumi.Input[str]] = None,
- enabled: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if address is not None:
- _setter("address", address)
+ pulumi.set(__self__, "address", address)
if enabled is not None:
- _setter("enabled", enabled)
+ pulumi.set(__self__, "enabled", enabled)
@property
@pulumi.getter
@@ -272,31 +204,12 @@ def __init__(__self__, *,
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] service_annotations: - Annotations to add to the ingress controller load balancer service. This is useful to configure properties of the managed load balancer, like the nature of the load balancer (e.g. ELB, NLB, ALB on AWS), the security groups, or various timeouts.
:param pulumi.Input[str] target_group_arn: - The ARN of a target group that the Ocean for Apache Spark ingress controller will be bound to. Set this to use an existing load balancer with Ocean for Apache Spark. Has no effect if using a managed load balancer. Only available on AWS.
"""
- OceanIngressLoadBalancerArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- managed=managed,
- service_annotations=service_annotations,
- target_group_arn=target_group_arn,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- managed: Optional[pulumi.Input[bool]] = None,
- service_annotations: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
- target_group_arn: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if service_annotations is None and 'serviceAnnotations' in kwargs:
- service_annotations = kwargs['serviceAnnotations']
- if target_group_arn is None and 'targetGroupArn' in kwargs:
- target_group_arn = kwargs['targetGroupArn']
-
if managed is not None:
- _setter("managed", managed)
+ pulumi.set(__self__, "managed", managed)
if service_annotations is not None:
- _setter("service_annotations", service_annotations)
+ pulumi.set(__self__, "service_annotations", service_annotations)
if target_group_arn is not None:
- _setter("target_group_arn", target_group_arn)
+ pulumi.set(__self__, "target_group_arn", target_group_arn)
@property
@pulumi.getter
@@ -344,25 +257,10 @@ def __init__(__self__, *,
:param pulumi.Input[bool] enabled: - Should the Ocean for Apache Spark control plane address the cluster using a custom endpoint. Use this to specify the DNS address of an externally provisioned (unmanaged) load balancer.
:param pulumi.Input[str] vpc_endpoint_service: - The name of the VPC Endpoint Service the Ocean for Apache Spark control plane should bind to.
"""
- OceanIngressPrivateLinkArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- enabled=enabled,
- vpc_endpoint_service=vpc_endpoint_service,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- enabled: Optional[pulumi.Input[bool]] = None,
- vpc_endpoint_service: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if vpc_endpoint_service is None and 'vpcEndpointService' in kwargs:
- vpc_endpoint_service = kwargs['vpcEndpointService']
-
if enabled is not None:
- _setter("enabled", enabled)
+ pulumi.set(__self__, "enabled", enabled)
if vpc_endpoint_service is not None:
- _setter("vpc_endpoint_service", vpc_endpoint_service)
+ pulumi.set(__self__, "vpc_endpoint_service", vpc_endpoint_service)
@property
@pulumi.getter
@@ -396,21 +294,8 @@ def __init__(__self__, *,
"""
:param pulumi.Input[bool] collect_app_logs: - Enable/Disable collecting driver and executor logs. When enabled, logs are stored by NetApp and can be downloaded from the Spot console web interface. The logs are deleted after 30 days.
"""
- OceanLogCollectionArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- collect_app_logs=collect_app_logs,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- collect_app_logs: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if collect_app_logs is None and 'collectAppLogs' in kwargs:
- collect_app_logs = kwargs['collectAppLogs']
-
if collect_app_logs is not None:
- _setter("collect_app_logs", collect_app_logs)
+ pulumi.set(__self__, "collect_app_logs", collect_app_logs)
@property
@pulumi.getter(name="collectAppLogs")
@@ -432,21 +317,8 @@ def __init__(__self__, *,
"""
:param pulumi.Input[Sequence[pulumi.Input[str]]] additional_app_namespaces: - List of Kubernetes namespaces that should be configured to run Spark applications, in addition to the default Spark application namespace `spark-apps`.
"""
- OceanSparkArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- additional_app_namespaces=additional_app_namespaces,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- additional_app_namespaces: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if additional_app_namespaces is None and 'additionalAppNamespaces' in kwargs:
- additional_app_namespaces = kwargs['additionalAppNamespaces']
-
if additional_app_namespaces is not None:
- _setter("additional_app_namespaces", additional_app_namespaces)
+ pulumi.set(__self__, "additional_app_namespaces", additional_app_namespaces)
@property
@pulumi.getter(name="additionalAppNamespaces")
@@ -470,27 +342,10 @@ def __init__(__self__, *,
:param pulumi.Input[Sequence[pulumi.Input[int]]] host_network_ports: - List of ports allowed to use on the host network - if empty default is `25554`.
:param pulumi.Input[bool] use_host_network: - Enable/disable host networking for the Spark Operator. Host networking can be useful when using custom CNI plugins like Calico on EKS.
"""
- OceanWebhookArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- host_network_ports=host_network_ports,
- use_host_network=use_host_network,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- host_network_ports: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]] = None,
- use_host_network: Optional[pulumi.Input[bool]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if host_network_ports is None and 'hostNetworkPorts' in kwargs:
- host_network_ports = kwargs['hostNetworkPorts']
- if use_host_network is None and 'useHostNetwork' in kwargs:
- use_host_network = kwargs['useHostNetwork']
-
if host_network_ports is not None:
- _setter("host_network_ports", host_network_ports)
+ pulumi.set(__self__, "host_network_ports", host_network_ports)
if use_host_network is not None:
- _setter("use_host_network", use_host_network)
+ pulumi.set(__self__, "use_host_network", use_host_network)
@property
@pulumi.getter(name="hostNetworkPorts")
diff --git a/sdk/python/pulumi_spotinst/spark/ocean.py b/sdk/python/pulumi_spotinst/spark/ocean.py
index 87cc685a..883a43a4 100644
--- a/sdk/python/pulumi_spotinst/spark/ocean.py
+++ b/sdk/python/pulumi_spotinst/spark/ocean.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs
from ._inputs import *
@@ -26,44 +26,17 @@ def __init__(__self__, *,
The set of arguments for constructing a Ocean resource.
:param pulumi.Input[str] ocean_cluster_id: - The ID of the Ocean cluster that Ocean for Apache Spark should be installed on.
"""
- OceanArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- ocean_cluster_id=ocean_cluster_id,
- compute=compute,
- ingress=ingress,
- log_collection=log_collection,
- spark=spark,
- webhook=webhook,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- ocean_cluster_id: Optional[pulumi.Input[str]] = None,
- compute: Optional[pulumi.Input['OceanComputeArgs']] = None,
- ingress: Optional[pulumi.Input['OceanIngressArgs']] = None,
- log_collection: Optional[pulumi.Input['OceanLogCollectionArgs']] = None,
- spark: Optional[pulumi.Input['OceanSparkArgs']] = None,
- webhook: Optional[pulumi.Input['OceanWebhookArgs']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if ocean_cluster_id is None and 'oceanClusterId' in kwargs:
- ocean_cluster_id = kwargs['oceanClusterId']
- if ocean_cluster_id is None:
- raise TypeError("Missing 'ocean_cluster_id' argument")
- if log_collection is None and 'logCollection' in kwargs:
- log_collection = kwargs['logCollection']
-
- _setter("ocean_cluster_id", ocean_cluster_id)
+ pulumi.set(__self__, "ocean_cluster_id", ocean_cluster_id)
if compute is not None:
- _setter("compute", compute)
+ pulumi.set(__self__, "compute", compute)
if ingress is not None:
- _setter("ingress", ingress)
+ pulumi.set(__self__, "ingress", ingress)
if log_collection is not None:
- _setter("log_collection", log_collection)
+ pulumi.set(__self__, "log_collection", log_collection)
if spark is not None:
- _setter("spark", spark)
+ pulumi.set(__self__, "spark", spark)
if webhook is not None:
- _setter("webhook", webhook)
+ pulumi.set(__self__, "webhook", webhook)
@property
@pulumi.getter(name="oceanClusterId")
@@ -136,43 +109,18 @@ def __init__(__self__, *,
Input properties used for looking up and filtering Ocean resources.
:param pulumi.Input[str] ocean_cluster_id: - The ID of the Ocean cluster that Ocean for Apache Spark should be installed on.
"""
- _OceanState._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- compute=compute,
- ingress=ingress,
- log_collection=log_collection,
- ocean_cluster_id=ocean_cluster_id,
- spark=spark,
- webhook=webhook,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- compute: Optional[pulumi.Input['OceanComputeArgs']] = None,
- ingress: Optional[pulumi.Input['OceanIngressArgs']] = None,
- log_collection: Optional[pulumi.Input['OceanLogCollectionArgs']] = None,
- ocean_cluster_id: Optional[pulumi.Input[str]] = None,
- spark: Optional[pulumi.Input['OceanSparkArgs']] = None,
- webhook: Optional[pulumi.Input['OceanWebhookArgs']] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if log_collection is None and 'logCollection' in kwargs:
- log_collection = kwargs['logCollection']
- if ocean_cluster_id is None and 'oceanClusterId' in kwargs:
- ocean_cluster_id = kwargs['oceanClusterId']
-
if compute is not None:
- _setter("compute", compute)
+ pulumi.set(__self__, "compute", compute)
if ingress is not None:
- _setter("ingress", ingress)
+ pulumi.set(__self__, "ingress", ingress)
if log_collection is not None:
- _setter("log_collection", log_collection)
+ pulumi.set(__self__, "log_collection", log_collection)
if ocean_cluster_id is not None:
- _setter("ocean_cluster_id", ocean_cluster_id)
+ pulumi.set(__self__, "ocean_cluster_id", ocean_cluster_id)
if spark is not None:
- _setter("spark", spark)
+ pulumi.set(__self__, "spark", spark)
if webhook is not None:
- _setter("webhook", webhook)
+ pulumi.set(__self__, "webhook", webhook)
@property
@pulumi.getter
@@ -384,10 +332,6 @@ def __init__(__self__, resource_name: str, *args, **kwargs):
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
- kwargs = kwargs or {}
- def _setter(key, value):
- kwargs[key] = value
- OceanArgs._configure(_setter, **kwargs)
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
@@ -408,18 +352,13 @@ def _internal_init(__self__,
raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
__props__ = OceanArgs.__new__(OceanArgs)
- compute = _utilities.configure(compute, OceanComputeArgs, True)
__props__.__dict__["compute"] = compute
- ingress = _utilities.configure(ingress, OceanIngressArgs, True)
__props__.__dict__["ingress"] = ingress
- log_collection = _utilities.configure(log_collection, OceanLogCollectionArgs, True)
__props__.__dict__["log_collection"] = log_collection
if ocean_cluster_id is None and not opts.urn:
raise TypeError("Missing required property 'ocean_cluster_id'")
__props__.__dict__["ocean_cluster_id"] = ocean_cluster_id
- spark = _utilities.configure(spark, OceanSparkArgs, True)
__props__.__dict__["spark"] = spark
- webhook = _utilities.configure(webhook, OceanWebhookArgs, True)
__props__.__dict__["webhook"] = webhook
super(Ocean, __self__).__init__(
'spotinst:spark/ocean:Ocean',
diff --git a/sdk/python/pulumi_spotinst/spark/ocean_virtual_node_group.py b/sdk/python/pulumi_spotinst/spark/ocean_virtual_node_group.py
index 46b87c4d..4b687b6c 100644
--- a/sdk/python/pulumi_spotinst/spark/ocean_virtual_node_group.py
+++ b/sdk/python/pulumi_spotinst/spark/ocean_virtual_node_group.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
__all__ = ['OceanVirtualNodeGroupArgs', 'OceanVirtualNodeGroup']
@@ -19,29 +19,8 @@ def __init__(__self__, *,
"""
The set of arguments for constructing a OceanVirtualNodeGroup resource.
"""
- OceanVirtualNodeGroupArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- ocean_spark_cluster_id=ocean_spark_cluster_id,
- virtual_node_group_id=virtual_node_group_id,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- ocean_spark_cluster_id: Optional[pulumi.Input[str]] = None,
- virtual_node_group_id: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if ocean_spark_cluster_id is None and 'oceanSparkClusterId' in kwargs:
- ocean_spark_cluster_id = kwargs['oceanSparkClusterId']
- if ocean_spark_cluster_id is None:
- raise TypeError("Missing 'ocean_spark_cluster_id' argument")
- if virtual_node_group_id is None and 'virtualNodeGroupId' in kwargs:
- virtual_node_group_id = kwargs['virtualNodeGroupId']
- if virtual_node_group_id is None:
- raise TypeError("Missing 'virtual_node_group_id' argument")
-
- _setter("ocean_spark_cluster_id", ocean_spark_cluster_id)
- _setter("virtual_node_group_id", virtual_node_group_id)
+ pulumi.set(__self__, "ocean_spark_cluster_id", ocean_spark_cluster_id)
+ pulumi.set(__self__, "virtual_node_group_id", virtual_node_group_id)
@property
@pulumi.getter(name="oceanSparkClusterId")
@@ -70,27 +49,10 @@ def __init__(__self__, *,
"""
Input properties used for looking up and filtering OceanVirtualNodeGroup resources.
"""
- _OceanVirtualNodeGroupState._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- ocean_spark_cluster_id=ocean_spark_cluster_id,
- virtual_node_group_id=virtual_node_group_id,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- ocean_spark_cluster_id: Optional[pulumi.Input[str]] = None,
- virtual_node_group_id: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if ocean_spark_cluster_id is None and 'oceanSparkClusterId' in kwargs:
- ocean_spark_cluster_id = kwargs['oceanSparkClusterId']
- if virtual_node_group_id is None and 'virtualNodeGroupId' in kwargs:
- virtual_node_group_id = kwargs['virtualNodeGroupId']
-
if ocean_spark_cluster_id is not None:
- _setter("ocean_spark_cluster_id", ocean_spark_cluster_id)
+ pulumi.set(__self__, "ocean_spark_cluster_id", ocean_spark_cluster_id)
if virtual_node_group_id is not None:
- _setter("virtual_node_group_id", virtual_node_group_id)
+ pulumi.set(__self__, "virtual_node_group_id", virtual_node_group_id)
@property
@pulumi.getter(name="oceanSparkClusterId")
@@ -174,10 +136,6 @@ def __init__(__self__, resource_name: str, *args, **kwargs):
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
- kwargs = kwargs or {}
- def _setter(key, value):
- kwargs[key] = value
- OceanVirtualNodeGroupArgs._configure(_setter, **kwargs)
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
diff --git a/sdk/python/pulumi_spotinst/spark/outputs.py b/sdk/python/pulumi_spotinst/spark/outputs.py
index 23a8d199..36a4f98d 100644
--- a/sdk/python/pulumi_spotinst/spark/outputs.py
+++ b/sdk/python/pulumi_spotinst/spark/outputs.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs
@@ -50,27 +50,10 @@ def __init__(__self__, *,
:param bool create_vngs: - Enable/disable the creation of Ocean Spark VNGs during cluster creation.
:param bool use_taints: - Enable/disable Ocean Spark taints on the Ocean Spark VNGs. By default, Ocean Spark uses taints to prevent non-Spark workloads from running on Ocean Spark VNGs.
"""
- OceanCompute._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- create_vngs=create_vngs,
- use_taints=use_taints,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- create_vngs: Optional[bool] = None,
- use_taints: Optional[bool] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if create_vngs is None and 'createVngs' in kwargs:
- create_vngs = kwargs['createVngs']
- if use_taints is None and 'useTaints' in kwargs:
- use_taints = kwargs['useTaints']
-
if create_vngs is not None:
- _setter("create_vngs", create_vngs)
+ pulumi.set(__self__, "create_vngs", create_vngs)
if use_taints is not None:
- _setter("use_taints", use_taints)
+ pulumi.set(__self__, "use_taints", use_taints)
@property
@pulumi.getter(name="createVngs")
@@ -123,43 +106,16 @@ def __init__(__self__, *,
"""
:param Mapping[str, str] service_annotations: - **DEPRECATED**: Use `load_balancer.service_annotations` instead.
"""
- OceanIngress._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- controller=controller,
- custom_endpoint=custom_endpoint,
- load_balancer=load_balancer,
- private_link=private_link,
- service_annotations=service_annotations,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- controller: Optional['outputs.OceanIngressController'] = None,
- custom_endpoint: Optional['outputs.OceanIngressCustomEndpoint'] = None,
- load_balancer: Optional['outputs.OceanIngressLoadBalancer'] = None,
- private_link: Optional['outputs.OceanIngressPrivateLink'] = None,
- service_annotations: Optional[Mapping[str, str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if custom_endpoint is None and 'customEndpoint' in kwargs:
- custom_endpoint = kwargs['customEndpoint']
- if load_balancer is None and 'loadBalancer' in kwargs:
- load_balancer = kwargs['loadBalancer']
- if private_link is None and 'privateLink' in kwargs:
- private_link = kwargs['privateLink']
- if service_annotations is None and 'serviceAnnotations' in kwargs:
- service_annotations = kwargs['serviceAnnotations']
-
if controller is not None:
- _setter("controller", controller)
+ pulumi.set(__self__, "controller", controller)
if custom_endpoint is not None:
- _setter("custom_endpoint", custom_endpoint)
+ pulumi.set(__self__, "custom_endpoint", custom_endpoint)
if load_balancer is not None:
- _setter("load_balancer", load_balancer)
+ pulumi.set(__self__, "load_balancer", load_balancer)
if private_link is not None:
- _setter("private_link", private_link)
+ pulumi.set(__self__, "private_link", private_link)
if service_annotations is not None:
- _setter("service_annotations", service_annotations)
+ pulumi.set(__self__, "service_annotations", service_annotations)
@property
@pulumi.getter
@@ -197,19 +153,8 @@ def __init__(__self__, *,
"""
:param bool managed: - Should an ingress controller managed by Ocean for Apache Spark be installed on the cluster.
"""
- OceanIngressController._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- managed=managed,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- managed: Optional[bool] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if managed is not None:
- _setter("managed", managed)
+ pulumi.set(__self__, "managed", managed)
@property
@pulumi.getter
@@ -229,23 +174,10 @@ def __init__(__self__, *,
:param str address: - The address the Ocean for Apache Spark control plane will use when addressing the cluster.
:param bool enabled: - Should the Ocean for Apache Spark control plane address the cluster using a custom endpoint. Use this to specify the DNS address of an externally provisioned (unmanaged) load balancer.
"""
- OceanIngressCustomEndpoint._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- address=address,
- enabled=enabled,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- address: Optional[str] = None,
- enabled: Optional[bool] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
-
if address is not None:
- _setter("address", address)
+ pulumi.set(__self__, "address", address)
if enabled is not None:
- _setter("enabled", enabled)
+ pulumi.set(__self__, "enabled", enabled)
@property
@pulumi.getter
@@ -294,31 +226,12 @@ def __init__(__self__, *,
:param Mapping[str, str] service_annotations: - Annotations to add to the ingress controller load balancer service. This is useful to configure properties of the managed load balancer, like the nature of the load balancer (e.g. ELB, NLB, ALB on AWS), the security groups, or various timeouts.
:param str target_group_arn: - The ARN of a target group that the Ocean for Apache Spark ingress controller will be bound to. Set this to use an existing load balancer with Ocean for Apache Spark. Has no effect if using a managed load balancer. Only available on AWS.
"""
- OceanIngressLoadBalancer._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- managed=managed,
- service_annotations=service_annotations,
- target_group_arn=target_group_arn,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- managed: Optional[bool] = None,
- service_annotations: Optional[Mapping[str, str]] = None,
- target_group_arn: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if service_annotations is None and 'serviceAnnotations' in kwargs:
- service_annotations = kwargs['serviceAnnotations']
- if target_group_arn is None and 'targetGroupArn' in kwargs:
- target_group_arn = kwargs['targetGroupArn']
-
if managed is not None:
- _setter("managed", managed)
+ pulumi.set(__self__, "managed", managed)
if service_annotations is not None:
- _setter("service_annotations", service_annotations)
+ pulumi.set(__self__, "service_annotations", service_annotations)
if target_group_arn is not None:
- _setter("target_group_arn", target_group_arn)
+ pulumi.set(__self__, "target_group_arn", target_group_arn)
@property
@pulumi.getter
@@ -371,25 +284,10 @@ def __init__(__self__, *,
:param bool enabled: - Should the Ocean for Apache Spark control plane address the cluster using a custom endpoint. Use this to specify the DNS address of an externally provisioned (unmanaged) load balancer.
:param str vpc_endpoint_service: - The name of the VPC Endpoint Service the Ocean for Apache Spark control plane should bind to.
"""
- OceanIngressPrivateLink._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- enabled=enabled,
- vpc_endpoint_service=vpc_endpoint_service,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- enabled: Optional[bool] = None,
- vpc_endpoint_service: Optional[str] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if vpc_endpoint_service is None and 'vpcEndpointService' in kwargs:
- vpc_endpoint_service = kwargs['vpcEndpointService']
-
if enabled is not None:
- _setter("enabled", enabled)
+ pulumi.set(__self__, "enabled", enabled)
if vpc_endpoint_service is not None:
- _setter("vpc_endpoint_service", vpc_endpoint_service)
+ pulumi.set(__self__, "vpc_endpoint_service", vpc_endpoint_service)
@property
@pulumi.getter
@@ -432,21 +330,8 @@ def __init__(__self__, *,
"""
:param bool collect_app_logs: - Enable/Disable collecting driver and executor logs. When enabled, logs are stored by NetApp and can be downloaded from the Spot console web interface. The logs are deleted after 30 days.
"""
- OceanLogCollection._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- collect_app_logs=collect_app_logs,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- collect_app_logs: Optional[bool] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if collect_app_logs is None and 'collectAppLogs' in kwargs:
- collect_app_logs = kwargs['collectAppLogs']
-
if collect_app_logs is not None:
- _setter("collect_app_logs", collect_app_logs)
+ pulumi.set(__self__, "collect_app_logs", collect_app_logs)
@property
@pulumi.getter(name="collectAppLogs")
@@ -481,21 +366,8 @@ def __init__(__self__, *,
"""
:param Sequence[str] additional_app_namespaces: - List of Kubernetes namespaces that should be configured to run Spark applications, in addition to the default Spark application namespace `spark-apps`.
"""
- OceanSpark._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- additional_app_namespaces=additional_app_namespaces,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- additional_app_namespaces: Optional[Sequence[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if additional_app_namespaces is None and 'additionalAppNamespaces' in kwargs:
- additional_app_namespaces = kwargs['additionalAppNamespaces']
-
if additional_app_namespaces is not None:
- _setter("additional_app_namespaces", additional_app_namespaces)
+ pulumi.set(__self__, "additional_app_namespaces", additional_app_namespaces)
@property
@pulumi.getter(name="additionalAppNamespaces")
@@ -534,27 +406,10 @@ def __init__(__self__, *,
:param Sequence[int] host_network_ports: - List of ports allowed to use on the host network - if empty default is `25554`.
:param bool use_host_network: - Enable/disable host networking for the Spark Operator. Host networking can be useful when using custom CNI plugins like Calico on EKS.
"""
- OceanWebhook._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- host_network_ports=host_network_ports,
- use_host_network=use_host_network,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- host_network_ports: Optional[Sequence[int]] = None,
- use_host_network: Optional[bool] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if host_network_ports is None and 'hostNetworkPorts' in kwargs:
- host_network_ports = kwargs['hostNetworkPorts']
- if use_host_network is None and 'useHostNetwork' in kwargs:
- use_host_network = kwargs['useHostNetwork']
-
if host_network_ports is not None:
- _setter("host_network_ports", host_network_ports)
+ pulumi.set(__self__, "host_network_ports", host_network_ports)
if use_host_network is not None:
- _setter("use_host_network", use_host_network)
+ pulumi.set(__self__, "use_host_network", use_host_network)
@property
@pulumi.getter(name="hostNetworkPorts")
diff --git a/sdk/python/pulumi_spotinst/stateful_node_azure.py b/sdk/python/pulumi_spotinst/stateful_node_azure.py
index e7bd1b83..754f09ac 100644
--- a/sdk/python/pulumi_spotinst/stateful_node_azure.py
+++ b/sdk/python/pulumi_spotinst/stateful_node_azure.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from . import _utilities
from . import outputs
from ._inputs import *
@@ -60,238 +60,79 @@ def __init__(__self__, *,
"""
The set of arguments for constructing a StatefulNodeAzure resource.
"""
- StatefulNodeAzureArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- od_sizes=od_sizes,
- os=os,
- region=region,
- resource_group_name=resource_group_name,
- should_persist_data_disks=should_persist_data_disks,
- should_persist_network=should_persist_network,
- should_persist_os_disk=should_persist_os_disk,
- spot_sizes=spot_sizes,
- strategy=strategy,
- attach_data_disks=attach_data_disks,
- boot_diagnostics=boot_diagnostics,
- custom_data=custom_data,
- data_disks=data_disks,
- data_disks_persistence_mode=data_disks_persistence_mode,
- deletes=deletes,
- description=description,
- detach_data_disks=detach_data_disks,
- extensions=extensions,
- health=health,
- image=image,
- import_vms=import_vms,
- load_balancers=load_balancers,
- login=login,
- managed_service_identities=managed_service_identities,
- name=name,
- network=network,
- os_disk=os_disk,
- os_disk_persistence_mode=os_disk_persistence_mode,
- preferred_spot_sizes=preferred_spot_sizes,
- preferred_zone=preferred_zone,
- scheduling_tasks=scheduling_tasks,
- secrets=secrets,
- security=security,
- should_persist_vm=should_persist_vm,
- shutdown_script=shutdown_script,
- signals=signals,
- tags=tags,
- update_states=update_states,
- user_data=user_data,
- vm_name=vm_name,
- zones=zones,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- od_sizes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- os: Optional[pulumi.Input[str]] = None,
- region: Optional[pulumi.Input[str]] = None,
- resource_group_name: Optional[pulumi.Input[str]] = None,
- should_persist_data_disks: Optional[pulumi.Input[bool]] = None,
- should_persist_network: Optional[pulumi.Input[bool]] = None,
- should_persist_os_disk: Optional[pulumi.Input[bool]] = None,
- spot_sizes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- strategy: Optional[pulumi.Input['StatefulNodeAzureStrategyArgs']] = None,
- attach_data_disks: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureAttachDataDiskArgs']]]] = None,
- boot_diagnostics: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureBootDiagnosticArgs']]]] = None,
- custom_data: Optional[pulumi.Input[str]] = None,
- data_disks: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureDataDiskArgs']]]] = None,
- data_disks_persistence_mode: Optional[pulumi.Input[str]] = None,
- deletes: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureDeleteArgs']]]] = None,
- description: Optional[pulumi.Input[str]] = None,
- detach_data_disks: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureDetachDataDiskArgs']]]] = None,
- extensions: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureExtensionArgs']]]] = None,
- health: Optional[pulumi.Input['StatefulNodeAzureHealthArgs']] = None,
- image: Optional[pulumi.Input['StatefulNodeAzureImageArgs']] = None,
- import_vms: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureImportVmArgs']]]] = None,
- load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureLoadBalancerArgs']]]] = None,
- login: Optional[pulumi.Input['StatefulNodeAzureLoginArgs']] = None,
- managed_service_identities: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureManagedServiceIdentityArgs']]]] = None,
- name: Optional[pulumi.Input[str]] = None,
- network: Optional[pulumi.Input['StatefulNodeAzureNetworkArgs']] = None,
- os_disk: Optional[pulumi.Input['StatefulNodeAzureOsDiskArgs']] = None,
- os_disk_persistence_mode: Optional[pulumi.Input[str]] = None,
- preferred_spot_sizes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- preferred_zone: Optional[pulumi.Input[str]] = None,
- scheduling_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureSchedulingTaskArgs']]]] = None,
- secrets: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureSecretArgs']]]] = None,
- security: Optional[pulumi.Input['StatefulNodeAzureSecurityArgs']] = None,
- should_persist_vm: Optional[pulumi.Input[bool]] = None,
- shutdown_script: Optional[pulumi.Input[str]] = None,
- signals: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureSignalArgs']]]] = None,
- tags: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureTagArgs']]]] = None,
- update_states: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureUpdateStateArgs']]]] = None,
- user_data: Optional[pulumi.Input[str]] = None,
- vm_name: Optional[pulumi.Input[str]] = None,
- zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if od_sizes is None and 'odSizes' in kwargs:
- od_sizes = kwargs['odSizes']
- if od_sizes is None:
- raise TypeError("Missing 'od_sizes' argument")
- if os is None:
- raise TypeError("Missing 'os' argument")
- if region is None:
- raise TypeError("Missing 'region' argument")
- if resource_group_name is None and 'resourceGroupName' in kwargs:
- resource_group_name = kwargs['resourceGroupName']
- if resource_group_name is None:
- raise TypeError("Missing 'resource_group_name' argument")
- if should_persist_data_disks is None and 'shouldPersistDataDisks' in kwargs:
- should_persist_data_disks = kwargs['shouldPersistDataDisks']
- if should_persist_data_disks is None:
- raise TypeError("Missing 'should_persist_data_disks' argument")
- if should_persist_network is None and 'shouldPersistNetwork' in kwargs:
- should_persist_network = kwargs['shouldPersistNetwork']
- if should_persist_network is None:
- raise TypeError("Missing 'should_persist_network' argument")
- if should_persist_os_disk is None and 'shouldPersistOsDisk' in kwargs:
- should_persist_os_disk = kwargs['shouldPersistOsDisk']
- if should_persist_os_disk is None:
- raise TypeError("Missing 'should_persist_os_disk' argument")
- if spot_sizes is None and 'spotSizes' in kwargs:
- spot_sizes = kwargs['spotSizes']
- if spot_sizes is None:
- raise TypeError("Missing 'spot_sizes' argument")
- if strategy is None:
- raise TypeError("Missing 'strategy' argument")
- if attach_data_disks is None and 'attachDataDisks' in kwargs:
- attach_data_disks = kwargs['attachDataDisks']
- if boot_diagnostics is None and 'bootDiagnostics' in kwargs:
- boot_diagnostics = kwargs['bootDiagnostics']
- if custom_data is None and 'customData' in kwargs:
- custom_data = kwargs['customData']
- if data_disks is None and 'dataDisks' in kwargs:
- data_disks = kwargs['dataDisks']
- if data_disks_persistence_mode is None and 'dataDisksPersistenceMode' in kwargs:
- data_disks_persistence_mode = kwargs['dataDisksPersistenceMode']
- if detach_data_disks is None and 'detachDataDisks' in kwargs:
- detach_data_disks = kwargs['detachDataDisks']
- if import_vms is None and 'importVms' in kwargs:
- import_vms = kwargs['importVms']
- if load_balancers is None and 'loadBalancers' in kwargs:
- load_balancers = kwargs['loadBalancers']
- if managed_service_identities is None and 'managedServiceIdentities' in kwargs:
- managed_service_identities = kwargs['managedServiceIdentities']
- if os_disk is None and 'osDisk' in kwargs:
- os_disk = kwargs['osDisk']
- if os_disk_persistence_mode is None and 'osDiskPersistenceMode' in kwargs:
- os_disk_persistence_mode = kwargs['osDiskPersistenceMode']
- if preferred_spot_sizes is None and 'preferredSpotSizes' in kwargs:
- preferred_spot_sizes = kwargs['preferredSpotSizes']
- if preferred_zone is None and 'preferredZone' in kwargs:
- preferred_zone = kwargs['preferredZone']
- if scheduling_tasks is None and 'schedulingTasks' in kwargs:
- scheduling_tasks = kwargs['schedulingTasks']
- if should_persist_vm is None and 'shouldPersistVm' in kwargs:
- should_persist_vm = kwargs['shouldPersistVm']
- if shutdown_script is None and 'shutdownScript' in kwargs:
- shutdown_script = kwargs['shutdownScript']
- if update_states is None and 'updateStates' in kwargs:
- update_states = kwargs['updateStates']
- if user_data is None and 'userData' in kwargs:
- user_data = kwargs['userData']
- if vm_name is None and 'vmName' in kwargs:
- vm_name = kwargs['vmName']
-
- _setter("od_sizes", od_sizes)
- _setter("os", os)
- _setter("region", region)
- _setter("resource_group_name", resource_group_name)
- _setter("should_persist_data_disks", should_persist_data_disks)
- _setter("should_persist_network", should_persist_network)
- _setter("should_persist_os_disk", should_persist_os_disk)
- _setter("spot_sizes", spot_sizes)
- _setter("strategy", strategy)
+ pulumi.set(__self__, "od_sizes", od_sizes)
+ pulumi.set(__self__, "os", os)
+ pulumi.set(__self__, "region", region)
+ pulumi.set(__self__, "resource_group_name", resource_group_name)
+ pulumi.set(__self__, "should_persist_data_disks", should_persist_data_disks)
+ pulumi.set(__self__, "should_persist_network", should_persist_network)
+ pulumi.set(__self__, "should_persist_os_disk", should_persist_os_disk)
+ pulumi.set(__self__, "spot_sizes", spot_sizes)
+ pulumi.set(__self__, "strategy", strategy)
if attach_data_disks is not None:
- _setter("attach_data_disks", attach_data_disks)
+ pulumi.set(__self__, "attach_data_disks", attach_data_disks)
if boot_diagnostics is not None:
- _setter("boot_diagnostics", boot_diagnostics)
+ pulumi.set(__self__, "boot_diagnostics", boot_diagnostics)
if custom_data is not None:
- _setter("custom_data", custom_data)
+ pulumi.set(__self__, "custom_data", custom_data)
if data_disks is not None:
- _setter("data_disks", data_disks)
+ pulumi.set(__self__, "data_disks", data_disks)
if data_disks_persistence_mode is not None:
- _setter("data_disks_persistence_mode", data_disks_persistence_mode)
+ pulumi.set(__self__, "data_disks_persistence_mode", data_disks_persistence_mode)
if deletes is not None:
- _setter("deletes", deletes)
+ pulumi.set(__self__, "deletes", deletes)
if description is not None:
- _setter("description", description)
+ pulumi.set(__self__, "description", description)
if detach_data_disks is not None:
- _setter("detach_data_disks", detach_data_disks)
+ pulumi.set(__self__, "detach_data_disks", detach_data_disks)
if extensions is not None:
- _setter("extensions", extensions)
+ pulumi.set(__self__, "extensions", extensions)
if health is not None:
- _setter("health", health)
+ pulumi.set(__self__, "health", health)
if image is not None:
- _setter("image", image)
+ pulumi.set(__self__, "image", image)
if import_vms is not None:
- _setter("import_vms", import_vms)
+ pulumi.set(__self__, "import_vms", import_vms)
if load_balancers is not None:
- _setter("load_balancers", load_balancers)
+ pulumi.set(__self__, "load_balancers", load_balancers)
if login is not None:
- _setter("login", login)
+ pulumi.set(__self__, "login", login)
if managed_service_identities is not None:
- _setter("managed_service_identities", managed_service_identities)
+ pulumi.set(__self__, "managed_service_identities", managed_service_identities)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if network is not None:
- _setter("network", network)
+ pulumi.set(__self__, "network", network)
if os_disk is not None:
- _setter("os_disk", os_disk)
+ pulumi.set(__self__, "os_disk", os_disk)
if os_disk_persistence_mode is not None:
- _setter("os_disk_persistence_mode", os_disk_persistence_mode)
+ pulumi.set(__self__, "os_disk_persistence_mode", os_disk_persistence_mode)
if preferred_spot_sizes is not None:
- _setter("preferred_spot_sizes", preferred_spot_sizes)
+ pulumi.set(__self__, "preferred_spot_sizes", preferred_spot_sizes)
if preferred_zone is not None:
- _setter("preferred_zone", preferred_zone)
+ pulumi.set(__self__, "preferred_zone", preferred_zone)
if scheduling_tasks is not None:
- _setter("scheduling_tasks", scheduling_tasks)
+ pulumi.set(__self__, "scheduling_tasks", scheduling_tasks)
if secrets is not None:
- _setter("secrets", secrets)
+ pulumi.set(__self__, "secrets", secrets)
if security is not None:
- _setter("security", security)
+ pulumi.set(__self__, "security", security)
if should_persist_vm is not None:
- _setter("should_persist_vm", should_persist_vm)
+ pulumi.set(__self__, "should_persist_vm", should_persist_vm)
if shutdown_script is not None:
- _setter("shutdown_script", shutdown_script)
+ pulumi.set(__self__, "shutdown_script", shutdown_script)
if signals is not None:
- _setter("signals", signals)
+ pulumi.set(__self__, "signals", signals)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
if update_states is not None:
- _setter("update_states", update_states)
+ pulumi.set(__self__, "update_states", update_states)
if user_data is not None:
- _setter("user_data", user_data)
+ pulumi.set(__self__, "user_data", user_data)
if vm_name is not None:
- _setter("vm_name", vm_name)
+ pulumi.set(__self__, "vm_name", vm_name)
if zones is not None:
- _setter("zones", zones)
+ pulumi.set(__self__, "zones", zones)
@property
@pulumi.getter(name="odSizes")
@@ -710,229 +551,88 @@ def __init__(__self__, *,
"""
Input properties used for looking up and filtering StatefulNodeAzure resources.
"""
- _StatefulNodeAzureState._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- attach_data_disks=attach_data_disks,
- boot_diagnostics=boot_diagnostics,
- custom_data=custom_data,
- data_disks=data_disks,
- data_disks_persistence_mode=data_disks_persistence_mode,
- deletes=deletes,
- description=description,
- detach_data_disks=detach_data_disks,
- extensions=extensions,
- health=health,
- image=image,
- import_vms=import_vms,
- load_balancers=load_balancers,
- login=login,
- managed_service_identities=managed_service_identities,
- name=name,
- network=network,
- od_sizes=od_sizes,
- os=os,
- os_disk=os_disk,
- os_disk_persistence_mode=os_disk_persistence_mode,
- preferred_spot_sizes=preferred_spot_sizes,
- preferred_zone=preferred_zone,
- region=region,
- resource_group_name=resource_group_name,
- scheduling_tasks=scheduling_tasks,
- secrets=secrets,
- security=security,
- should_persist_data_disks=should_persist_data_disks,
- should_persist_network=should_persist_network,
- should_persist_os_disk=should_persist_os_disk,
- should_persist_vm=should_persist_vm,
- shutdown_script=shutdown_script,
- signals=signals,
- spot_sizes=spot_sizes,
- strategy=strategy,
- tags=tags,
- update_states=update_states,
- user_data=user_data,
- vm_name=vm_name,
- zones=zones,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- attach_data_disks: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureAttachDataDiskArgs']]]] = None,
- boot_diagnostics: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureBootDiagnosticArgs']]]] = None,
- custom_data: Optional[pulumi.Input[str]] = None,
- data_disks: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureDataDiskArgs']]]] = None,
- data_disks_persistence_mode: Optional[pulumi.Input[str]] = None,
- deletes: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureDeleteArgs']]]] = None,
- description: Optional[pulumi.Input[str]] = None,
- detach_data_disks: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureDetachDataDiskArgs']]]] = None,
- extensions: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureExtensionArgs']]]] = None,
- health: Optional[pulumi.Input['StatefulNodeAzureHealthArgs']] = None,
- image: Optional[pulumi.Input['StatefulNodeAzureImageArgs']] = None,
- import_vms: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureImportVmArgs']]]] = None,
- load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureLoadBalancerArgs']]]] = None,
- login: Optional[pulumi.Input['StatefulNodeAzureLoginArgs']] = None,
- managed_service_identities: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureManagedServiceIdentityArgs']]]] = None,
- name: Optional[pulumi.Input[str]] = None,
- network: Optional[pulumi.Input['StatefulNodeAzureNetworkArgs']] = None,
- od_sizes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- os: Optional[pulumi.Input[str]] = None,
- os_disk: Optional[pulumi.Input['StatefulNodeAzureOsDiskArgs']] = None,
- os_disk_persistence_mode: Optional[pulumi.Input[str]] = None,
- preferred_spot_sizes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- preferred_zone: Optional[pulumi.Input[str]] = None,
- region: Optional[pulumi.Input[str]] = None,
- resource_group_name: Optional[pulumi.Input[str]] = None,
- scheduling_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureSchedulingTaskArgs']]]] = None,
- secrets: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureSecretArgs']]]] = None,
- security: Optional[pulumi.Input['StatefulNodeAzureSecurityArgs']] = None,
- should_persist_data_disks: Optional[pulumi.Input[bool]] = None,
- should_persist_network: Optional[pulumi.Input[bool]] = None,
- should_persist_os_disk: Optional[pulumi.Input[bool]] = None,
- should_persist_vm: Optional[pulumi.Input[bool]] = None,
- shutdown_script: Optional[pulumi.Input[str]] = None,
- signals: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureSignalArgs']]]] = None,
- spot_sizes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- strategy: Optional[pulumi.Input['StatefulNodeAzureStrategyArgs']] = None,
- tags: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureTagArgs']]]] = None,
- update_states: Optional[pulumi.Input[Sequence[pulumi.Input['StatefulNodeAzureUpdateStateArgs']]]] = None,
- user_data: Optional[pulumi.Input[str]] = None,
- vm_name: Optional[pulumi.Input[str]] = None,
- zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if attach_data_disks is None and 'attachDataDisks' in kwargs:
- attach_data_disks = kwargs['attachDataDisks']
- if boot_diagnostics is None and 'bootDiagnostics' in kwargs:
- boot_diagnostics = kwargs['bootDiagnostics']
- if custom_data is None and 'customData' in kwargs:
- custom_data = kwargs['customData']
- if data_disks is None and 'dataDisks' in kwargs:
- data_disks = kwargs['dataDisks']
- if data_disks_persistence_mode is None and 'dataDisksPersistenceMode' in kwargs:
- data_disks_persistence_mode = kwargs['dataDisksPersistenceMode']
- if detach_data_disks is None and 'detachDataDisks' in kwargs:
- detach_data_disks = kwargs['detachDataDisks']
- if import_vms is None and 'importVms' in kwargs:
- import_vms = kwargs['importVms']
- if load_balancers is None and 'loadBalancers' in kwargs:
- load_balancers = kwargs['loadBalancers']
- if managed_service_identities is None and 'managedServiceIdentities' in kwargs:
- managed_service_identities = kwargs['managedServiceIdentities']
- if od_sizes is None and 'odSizes' in kwargs:
- od_sizes = kwargs['odSizes']
- if os_disk is None and 'osDisk' in kwargs:
- os_disk = kwargs['osDisk']
- if os_disk_persistence_mode is None and 'osDiskPersistenceMode' in kwargs:
- os_disk_persistence_mode = kwargs['osDiskPersistenceMode']
- if preferred_spot_sizes is None and 'preferredSpotSizes' in kwargs:
- preferred_spot_sizes = kwargs['preferredSpotSizes']
- if preferred_zone is None and 'preferredZone' in kwargs:
- preferred_zone = kwargs['preferredZone']
- if resource_group_name is None and 'resourceGroupName' in kwargs:
- resource_group_name = kwargs['resourceGroupName']
- if scheduling_tasks is None and 'schedulingTasks' in kwargs:
- scheduling_tasks = kwargs['schedulingTasks']
- if should_persist_data_disks is None and 'shouldPersistDataDisks' in kwargs:
- should_persist_data_disks = kwargs['shouldPersistDataDisks']
- if should_persist_network is None and 'shouldPersistNetwork' in kwargs:
- should_persist_network = kwargs['shouldPersistNetwork']
- if should_persist_os_disk is None and 'shouldPersistOsDisk' in kwargs:
- should_persist_os_disk = kwargs['shouldPersistOsDisk']
- if should_persist_vm is None and 'shouldPersistVm' in kwargs:
- should_persist_vm = kwargs['shouldPersistVm']
- if shutdown_script is None and 'shutdownScript' in kwargs:
- shutdown_script = kwargs['shutdownScript']
- if spot_sizes is None and 'spotSizes' in kwargs:
- spot_sizes = kwargs['spotSizes']
- if update_states is None and 'updateStates' in kwargs:
- update_states = kwargs['updateStates']
- if user_data is None and 'userData' in kwargs:
- user_data = kwargs['userData']
- if vm_name is None and 'vmName' in kwargs:
- vm_name = kwargs['vmName']
-
if attach_data_disks is not None:
- _setter("attach_data_disks", attach_data_disks)
+ pulumi.set(__self__, "attach_data_disks", attach_data_disks)
if boot_diagnostics is not None:
- _setter("boot_diagnostics", boot_diagnostics)
+ pulumi.set(__self__, "boot_diagnostics", boot_diagnostics)
if custom_data is not None:
- _setter("custom_data", custom_data)
+ pulumi.set(__self__, "custom_data", custom_data)
if data_disks is not None:
- _setter("data_disks", data_disks)
+ pulumi.set(__self__, "data_disks", data_disks)
if data_disks_persistence_mode is not None:
- _setter("data_disks_persistence_mode", data_disks_persistence_mode)
+ pulumi.set(__self__, "data_disks_persistence_mode", data_disks_persistence_mode)
if deletes is not None:
- _setter("deletes", deletes)
+ pulumi.set(__self__, "deletes", deletes)
if description is not None:
- _setter("description", description)
+ pulumi.set(__self__, "description", description)
if detach_data_disks is not None:
- _setter("detach_data_disks", detach_data_disks)
+ pulumi.set(__self__, "detach_data_disks", detach_data_disks)
if extensions is not None:
- _setter("extensions", extensions)
+ pulumi.set(__self__, "extensions", extensions)
if health is not None:
- _setter("health", health)
+ pulumi.set(__self__, "health", health)
if image is not None:
- _setter("image", image)
+ pulumi.set(__self__, "image", image)
if import_vms is not None:
- _setter("import_vms", import_vms)
+ pulumi.set(__self__, "import_vms", import_vms)
if load_balancers is not None:
- _setter("load_balancers", load_balancers)
+ pulumi.set(__self__, "load_balancers", load_balancers)
if login is not None:
- _setter("login", login)
+ pulumi.set(__self__, "login", login)
if managed_service_identities is not None:
- _setter("managed_service_identities", managed_service_identities)
+ pulumi.set(__self__, "managed_service_identities", managed_service_identities)
if name is not None:
- _setter("name", name)
+ pulumi.set(__self__, "name", name)
if network is not None:
- _setter("network", network)
+ pulumi.set(__self__, "network", network)
if od_sizes is not None:
- _setter("od_sizes", od_sizes)
+ pulumi.set(__self__, "od_sizes", od_sizes)
if os is not None:
- _setter("os", os)
+ pulumi.set(__self__, "os", os)
if os_disk is not None:
- _setter("os_disk", os_disk)
+ pulumi.set(__self__, "os_disk", os_disk)
if os_disk_persistence_mode is not None:
- _setter("os_disk_persistence_mode", os_disk_persistence_mode)
+ pulumi.set(__self__, "os_disk_persistence_mode", os_disk_persistence_mode)
if preferred_spot_sizes is not None:
- _setter("preferred_spot_sizes", preferred_spot_sizes)
+ pulumi.set(__self__, "preferred_spot_sizes", preferred_spot_sizes)
if preferred_zone is not None:
- _setter("preferred_zone", preferred_zone)
+ pulumi.set(__self__, "preferred_zone", preferred_zone)
if region is not None:
- _setter("region", region)
+ pulumi.set(__self__, "region", region)
if resource_group_name is not None:
- _setter("resource_group_name", resource_group_name)
+ pulumi.set(__self__, "resource_group_name", resource_group_name)
if scheduling_tasks is not None:
- _setter("scheduling_tasks", scheduling_tasks)
+ pulumi.set(__self__, "scheduling_tasks", scheduling_tasks)
if secrets is not None:
- _setter("secrets", secrets)
+ pulumi.set(__self__, "secrets", secrets)
if security is not None:
- _setter("security", security)
+ pulumi.set(__self__, "security", security)
if should_persist_data_disks is not None:
- _setter("should_persist_data_disks", should_persist_data_disks)
+ pulumi.set(__self__, "should_persist_data_disks", should_persist_data_disks)
if should_persist_network is not None:
- _setter("should_persist_network", should_persist_network)
+ pulumi.set(__self__, "should_persist_network", should_persist_network)
if should_persist_os_disk is not None:
- _setter("should_persist_os_disk", should_persist_os_disk)
+ pulumi.set(__self__, "should_persist_os_disk", should_persist_os_disk)
if should_persist_vm is not None:
- _setter("should_persist_vm", should_persist_vm)
+ pulumi.set(__self__, "should_persist_vm", should_persist_vm)
if shutdown_script is not None:
- _setter("shutdown_script", shutdown_script)
+ pulumi.set(__self__, "shutdown_script", shutdown_script)
if signals is not None:
- _setter("signals", signals)
+ pulumi.set(__self__, "signals", signals)
if spot_sizes is not None:
- _setter("spot_sizes", spot_sizes)
+ pulumi.set(__self__, "spot_sizes", spot_sizes)
if strategy is not None:
- _setter("strategy", strategy)
+ pulumi.set(__self__, "strategy", strategy)
if tags is not None:
- _setter("tags", tags)
+ pulumi.set(__self__, "tags", tags)
if update_states is not None:
- _setter("update_states", update_states)
+ pulumi.set(__self__, "update_states", update_states)
if user_data is not None:
- _setter("user_data", user_data)
+ pulumi.set(__self__, "user_data", user_data)
if vm_name is not None:
- _setter("vm_name", vm_name)
+ pulumi.set(__self__, "vm_name", vm_name)
if zones is not None:
- _setter("zones", zones)
+ pulumi.set(__self__, "zones", zones)
@property
@pulumi.getter(name="attachDataDisks")
@@ -1876,10 +1576,6 @@ def __init__(__self__, resource_name: str, *args, **kwargs):
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
- kwargs = kwargs or {}
- def _setter(key, value):
- kwargs[key] = value
- StatefulNodeAzureArgs._configure(_setter, **kwargs)
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
@@ -1944,17 +1640,13 @@ def _internal_init(__self__,
__props__.__dict__["description"] = description
__props__.__dict__["detach_data_disks"] = detach_data_disks
__props__.__dict__["extensions"] = extensions
- health = _utilities.configure(health, StatefulNodeAzureHealthArgs, True)
__props__.__dict__["health"] = health
- image = _utilities.configure(image, StatefulNodeAzureImageArgs, True)
__props__.__dict__["image"] = image
__props__.__dict__["import_vms"] = import_vms
__props__.__dict__["load_balancers"] = load_balancers
- login = _utilities.configure(login, StatefulNodeAzureLoginArgs, True)
__props__.__dict__["login"] = login
__props__.__dict__["managed_service_identities"] = managed_service_identities
__props__.__dict__["name"] = name
- network = _utilities.configure(network, StatefulNodeAzureNetworkArgs, True)
__props__.__dict__["network"] = network
if od_sizes is None and not opts.urn:
raise TypeError("Missing required property 'od_sizes'")
@@ -1962,7 +1654,6 @@ def _internal_init(__self__,
if os is None and not opts.urn:
raise TypeError("Missing required property 'os'")
__props__.__dict__["os"] = os
- os_disk = _utilities.configure(os_disk, StatefulNodeAzureOsDiskArgs, True)
__props__.__dict__["os_disk"] = os_disk
__props__.__dict__["os_disk_persistence_mode"] = os_disk_persistence_mode
__props__.__dict__["preferred_spot_sizes"] = preferred_spot_sizes
@@ -1975,7 +1666,6 @@ def _internal_init(__self__,
__props__.__dict__["resource_group_name"] = resource_group_name
__props__.__dict__["scheduling_tasks"] = scheduling_tasks
__props__.__dict__["secrets"] = secrets
- security = _utilities.configure(security, StatefulNodeAzureSecurityArgs, True)
__props__.__dict__["security"] = security
if should_persist_data_disks is None and not opts.urn:
raise TypeError("Missing required property 'should_persist_data_disks'")
@@ -1992,7 +1682,6 @@ def _internal_init(__self__,
if spot_sizes is None and not opts.urn:
raise TypeError("Missing required property 'spot_sizes'")
__props__.__dict__["spot_sizes"] = spot_sizes
- strategy = _utilities.configure(strategy, StatefulNodeAzureStrategyArgs, True)
if strategy is None and not opts.urn:
raise TypeError("Missing required property 'strategy'")
__props__.__dict__["strategy"] = strategy
diff --git a/sdk/python/pulumi_spotinst/subscription.py b/sdk/python/pulumi_spotinst/subscription.py
index d75d3f1a..95dd13b9 100644
--- a/sdk/python/pulumi_spotinst/subscription.py
+++ b/sdk/python/pulumi_spotinst/subscription.py
@@ -6,7 +6,7 @@
import warnings
import pulumi
import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
from . import _utilities
__all__ = ['SubscriptionArgs', 'Subscription']
@@ -42,43 +42,12 @@ def __init__(__self__, *,
Example: {"event": `"event"`, `"resourceId"`: `"resource-id"`, `"resourceName"`: `"resource-name"`", `"myCustomKey"`: `"My content is set here"` }
Default: {`"event"`: `""`, `"instanceId"`: `""`, `"resourceId"`: `""`, `"resourceName"`: `""` }.
"""
- SubscriptionArgs._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- endpoint=endpoint,
- event_type=event_type,
- protocol=protocol,
- resource_id=resource_id,
- format=format,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- endpoint: Optional[pulumi.Input[str]] = None,
- event_type: Optional[pulumi.Input[str]] = None,
- protocol: Optional[pulumi.Input[str]] = None,
- resource_id: Optional[pulumi.Input[str]] = None,
- format: Optional[pulumi.Input[Mapping[str, Any]]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if endpoint is None:
- raise TypeError("Missing 'endpoint' argument")
- if event_type is None and 'eventType' in kwargs:
- event_type = kwargs['eventType']
- if event_type is None:
- raise TypeError("Missing 'event_type' argument")
- if protocol is None:
- raise TypeError("Missing 'protocol' argument")
- if resource_id is None and 'resourceId' in kwargs:
- resource_id = kwargs['resourceId']
- if resource_id is None:
- raise TypeError("Missing 'resource_id' argument")
-
- _setter("endpoint", endpoint)
- _setter("event_type", event_type)
- _setter("protocol", protocol)
- _setter("resource_id", resource_id)
+ pulumi.set(__self__, "endpoint", endpoint)
+ pulumi.set(__self__, "event_type", event_type)
+ pulumi.set(__self__, "protocol", protocol)
+ pulumi.set(__self__, "resource_id", resource_id)
if format is not None:
- _setter("format", format)
+ pulumi.set(__self__, "format", format)
@property
@pulumi.getter
@@ -187,39 +156,16 @@ def __init__(__self__, *,
`"aws-sns"` is only supported with AWS provider
:param pulumi.Input[str] resource_id: Spotinst Resource id (Elastigroup or Ocean ID).
"""
- _SubscriptionState._configure(
- lambda key, value: pulumi.set(__self__, key, value),
- endpoint=endpoint,
- event_type=event_type,
- format=format,
- protocol=protocol,
- resource_id=resource_id,
- )
- @staticmethod
- def _configure(
- _setter: Callable[[Any, Any], None],
- endpoint: Optional[pulumi.Input[str]] = None,
- event_type: Optional[pulumi.Input[str]] = None,
- format: Optional[pulumi.Input[Mapping[str, Any]]] = None,
- protocol: Optional[pulumi.Input[str]] = None,
- resource_id: Optional[pulumi.Input[str]] = None,
- opts: Optional[pulumi.ResourceOptions] = None,
- **kwargs):
- if event_type is None and 'eventType' in kwargs:
- event_type = kwargs['eventType']
- if resource_id is None and 'resourceId' in kwargs:
- resource_id = kwargs['resourceId']
-
if endpoint is not None:
- _setter("endpoint", endpoint)
+ pulumi.set(__self__, "endpoint", endpoint)
if event_type is not None:
- _setter("event_type", event_type)
+ pulumi.set(__self__, "event_type", event_type)
if format is not None:
- _setter("format", format)
+ pulumi.set(__self__, "format", format)
if protocol is not None:
- _setter("protocol", protocol)
+ pulumi.set(__self__, "protocol", protocol)
if resource_id is not None:
- _setter("resource_id", resource_id)
+ pulumi.set(__self__, "resource_id", resource_id)
@property
@pulumi.getter
@@ -395,10 +341,6 @@ def __init__(__self__, resource_name: str, *args, **kwargs):
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
- kwargs = kwargs or {}
- def _setter(key, value):
- kwargs[key] = value
- SubscriptionArgs._configure(_setter, **kwargs)
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,