pulumi-nomad 2.0.1__py3-none-any.whl → 2.1.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- pulumi_nomad/acl_auth_method.py +64 -1
- pulumi_nomad/csi_volume.py +90 -84
- pulumi_nomad/csi_volume_registration.py +156 -82
- pulumi_nomad/job.py +82 -0
- {pulumi_nomad-2.0.1.dist-info → pulumi_nomad-2.1.0.dist-info}/METADATA +1 -1
- {pulumi_nomad-2.0.1.dist-info → pulumi_nomad-2.1.0.dist-info}/RECORD +8 -8
- {pulumi_nomad-2.0.1.dist-info → pulumi_nomad-2.1.0.dist-info}/WHEEL +0 -0
- {pulumi_nomad-2.0.1.dist-info → pulumi_nomad-2.1.0.dist-info}/top_level.txt +0 -0
pulumi_nomad/acl_auth_method.py
CHANGED
|
@@ -21,7 +21,8 @@ class AclAuthMethodArgs:
|
|
|
21
21
|
token_locality: pulumi.Input[str],
|
|
22
22
|
type: pulumi.Input[str],
|
|
23
23
|
default: Optional[pulumi.Input[bool]] = None,
|
|
24
|
-
name: Optional[pulumi.Input[str]] = None
|
|
24
|
+
name: Optional[pulumi.Input[str]] = None,
|
|
25
|
+
token_name_format: Optional[pulumi.Input[str]] = None):
|
|
25
26
|
"""
|
|
26
27
|
The set of arguments for constructing a AclAuthMethod resource.
|
|
27
28
|
:param pulumi.Input['AclAuthMethodConfigArgs'] config: Configuration specific to the auth method provider.
|
|
@@ -35,6 +36,9 @@ class AclAuthMethodArgs:
|
|
|
35
36
|
:param pulumi.Input[bool] default: `(bool: false)` - Defines whether this ACL Auth Method is to be set
|
|
36
37
|
as default.
|
|
37
38
|
:param pulumi.Input[str] name: `(string: <required>)` - The identifier of the ACL Auth Method.
|
|
39
|
+
:param pulumi.Input[str] token_name_format: `(string: <optional>)` - Defines the token name format for the
|
|
40
|
+
generated tokens This can be lightly templated using HIL '${foo}' syntax.
|
|
41
|
+
Defaults to `${auth_method_type}-${auth_method_name}`.
|
|
38
42
|
"""
|
|
39
43
|
pulumi.set(__self__, "config", config)
|
|
40
44
|
pulumi.set(__self__, "max_token_ttl", max_token_ttl)
|
|
@@ -44,6 +48,8 @@ class AclAuthMethodArgs:
|
|
|
44
48
|
pulumi.set(__self__, "default", default)
|
|
45
49
|
if name is not None:
|
|
46
50
|
pulumi.set(__self__, "name", name)
|
|
51
|
+
if token_name_format is not None:
|
|
52
|
+
pulumi.set(__self__, "token_name_format", token_name_format)
|
|
47
53
|
|
|
48
54
|
@property
|
|
49
55
|
@pulumi.getter
|
|
@@ -122,6 +128,20 @@ class AclAuthMethodArgs:
|
|
|
122
128
|
def name(self, value: Optional[pulumi.Input[str]]):
|
|
123
129
|
pulumi.set(self, "name", value)
|
|
124
130
|
|
|
131
|
+
@property
|
|
132
|
+
@pulumi.getter(name="tokenNameFormat")
|
|
133
|
+
def token_name_format(self) -> Optional[pulumi.Input[str]]:
|
|
134
|
+
"""
|
|
135
|
+
`(string: <optional>)` - Defines the token name format for the
|
|
136
|
+
generated tokens This can be lightly templated using HIL '${foo}' syntax.
|
|
137
|
+
Defaults to `${auth_method_type}-${auth_method_name}`.
|
|
138
|
+
"""
|
|
139
|
+
return pulumi.get(self, "token_name_format")
|
|
140
|
+
|
|
141
|
+
@token_name_format.setter
|
|
142
|
+
def token_name_format(self, value: Optional[pulumi.Input[str]]):
|
|
143
|
+
pulumi.set(self, "token_name_format", value)
|
|
144
|
+
|
|
125
145
|
|
|
126
146
|
@pulumi.input_type
|
|
127
147
|
class _AclAuthMethodState:
|
|
@@ -131,6 +151,7 @@ class _AclAuthMethodState:
|
|
|
131
151
|
max_token_ttl: Optional[pulumi.Input[str]] = None,
|
|
132
152
|
name: Optional[pulumi.Input[str]] = None,
|
|
133
153
|
token_locality: Optional[pulumi.Input[str]] = None,
|
|
154
|
+
token_name_format: Optional[pulumi.Input[str]] = None,
|
|
134
155
|
type: Optional[pulumi.Input[str]] = None):
|
|
135
156
|
"""
|
|
136
157
|
Input properties used for looking up and filtering AclAuthMethod resources.
|
|
@@ -143,6 +164,9 @@ class _AclAuthMethodState:
|
|
|
143
164
|
:param pulumi.Input[str] token_locality: `(string: <required>)` - Defines whether the ACL Auth Method
|
|
144
165
|
creates a local or global token when performing SSO login. This field must be
|
|
145
166
|
set to either `local` or `global`.
|
|
167
|
+
:param pulumi.Input[str] token_name_format: `(string: <optional>)` - Defines the token name format for the
|
|
168
|
+
generated tokens This can be lightly templated using HIL '${foo}' syntax.
|
|
169
|
+
Defaults to `${auth_method_type}-${auth_method_name}`.
|
|
146
170
|
:param pulumi.Input[str] type: `(string: <required>)` - ACL Auth Method SSO workflow type. Currently,
|
|
147
171
|
the only supported type is `OIDC`.
|
|
148
172
|
"""
|
|
@@ -156,6 +180,8 @@ class _AclAuthMethodState:
|
|
|
156
180
|
pulumi.set(__self__, "name", name)
|
|
157
181
|
if token_locality is not None:
|
|
158
182
|
pulumi.set(__self__, "token_locality", token_locality)
|
|
183
|
+
if token_name_format is not None:
|
|
184
|
+
pulumi.set(__self__, "token_name_format", token_name_format)
|
|
159
185
|
if type is not None:
|
|
160
186
|
pulumi.set(__self__, "type", type)
|
|
161
187
|
|
|
@@ -223,6 +249,20 @@ class _AclAuthMethodState:
|
|
|
223
249
|
def token_locality(self, value: Optional[pulumi.Input[str]]):
|
|
224
250
|
pulumi.set(self, "token_locality", value)
|
|
225
251
|
|
|
252
|
+
@property
|
|
253
|
+
@pulumi.getter(name="tokenNameFormat")
|
|
254
|
+
def token_name_format(self) -> Optional[pulumi.Input[str]]:
|
|
255
|
+
"""
|
|
256
|
+
`(string: <optional>)` - Defines the token name format for the
|
|
257
|
+
generated tokens This can be lightly templated using HIL '${foo}' syntax.
|
|
258
|
+
Defaults to `${auth_method_type}-${auth_method_name}`.
|
|
259
|
+
"""
|
|
260
|
+
return pulumi.get(self, "token_name_format")
|
|
261
|
+
|
|
262
|
+
@token_name_format.setter
|
|
263
|
+
def token_name_format(self, value: Optional[pulumi.Input[str]]):
|
|
264
|
+
pulumi.set(self, "token_name_format", value)
|
|
265
|
+
|
|
226
266
|
@property
|
|
227
267
|
@pulumi.getter
|
|
228
268
|
def type(self) -> Optional[pulumi.Input[str]]:
|
|
@@ -247,6 +287,7 @@ class AclAuthMethod(pulumi.CustomResource):
|
|
|
247
287
|
max_token_ttl: Optional[pulumi.Input[str]] = None,
|
|
248
288
|
name: Optional[pulumi.Input[str]] = None,
|
|
249
289
|
token_locality: Optional[pulumi.Input[str]] = None,
|
|
290
|
+
token_name_format: Optional[pulumi.Input[str]] = None,
|
|
250
291
|
type: Optional[pulumi.Input[str]] = None,
|
|
251
292
|
__props__=None):
|
|
252
293
|
"""
|
|
@@ -264,6 +305,7 @@ class AclAuthMethod(pulumi.CustomResource):
|
|
|
264
305
|
type="OIDC",
|
|
265
306
|
token_locality="global",
|
|
266
307
|
max_token_ttl="10m0s",
|
|
308
|
+
token_name_format="${auth_method_type}-${value.user}",
|
|
267
309
|
default=True,
|
|
268
310
|
config=nomad.AclAuthMethodConfigArgs(
|
|
269
311
|
oidc_discovery_url="https://uk.auth0.com/",
|
|
@@ -291,6 +333,9 @@ class AclAuthMethod(pulumi.CustomResource):
|
|
|
291
333
|
:param pulumi.Input[str] token_locality: `(string: <required>)` - Defines whether the ACL Auth Method
|
|
292
334
|
creates a local or global token when performing SSO login. This field must be
|
|
293
335
|
set to either `local` or `global`.
|
|
336
|
+
:param pulumi.Input[str] token_name_format: `(string: <optional>)` - Defines the token name format for the
|
|
337
|
+
generated tokens This can be lightly templated using HIL '${foo}' syntax.
|
|
338
|
+
Defaults to `${auth_method_type}-${auth_method_name}`.
|
|
294
339
|
:param pulumi.Input[str] type: `(string: <required>)` - ACL Auth Method SSO workflow type. Currently,
|
|
295
340
|
the only supported type is `OIDC`.
|
|
296
341
|
"""
|
|
@@ -315,6 +360,7 @@ class AclAuthMethod(pulumi.CustomResource):
|
|
|
315
360
|
type="OIDC",
|
|
316
361
|
token_locality="global",
|
|
317
362
|
max_token_ttl="10m0s",
|
|
363
|
+
token_name_format="${auth_method_type}-${value.user}",
|
|
318
364
|
default=True,
|
|
319
365
|
config=nomad.AclAuthMethodConfigArgs(
|
|
320
366
|
oidc_discovery_url="https://uk.auth0.com/",
|
|
@@ -351,6 +397,7 @@ class AclAuthMethod(pulumi.CustomResource):
|
|
|
351
397
|
max_token_ttl: Optional[pulumi.Input[str]] = None,
|
|
352
398
|
name: Optional[pulumi.Input[str]] = None,
|
|
353
399
|
token_locality: Optional[pulumi.Input[str]] = None,
|
|
400
|
+
token_name_format: Optional[pulumi.Input[str]] = None,
|
|
354
401
|
type: Optional[pulumi.Input[str]] = None,
|
|
355
402
|
__props__=None):
|
|
356
403
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
@@ -372,6 +419,7 @@ class AclAuthMethod(pulumi.CustomResource):
|
|
|
372
419
|
if token_locality is None and not opts.urn:
|
|
373
420
|
raise TypeError("Missing required property 'token_locality'")
|
|
374
421
|
__props__.__dict__["token_locality"] = token_locality
|
|
422
|
+
__props__.__dict__["token_name_format"] = token_name_format
|
|
375
423
|
if type is None and not opts.urn:
|
|
376
424
|
raise TypeError("Missing required property 'type'")
|
|
377
425
|
__props__.__dict__["type"] = type
|
|
@@ -390,6 +438,7 @@ class AclAuthMethod(pulumi.CustomResource):
|
|
|
390
438
|
max_token_ttl: Optional[pulumi.Input[str]] = None,
|
|
391
439
|
name: Optional[pulumi.Input[str]] = None,
|
|
392
440
|
token_locality: Optional[pulumi.Input[str]] = None,
|
|
441
|
+
token_name_format: Optional[pulumi.Input[str]] = None,
|
|
393
442
|
type: Optional[pulumi.Input[str]] = None) -> 'AclAuthMethod':
|
|
394
443
|
"""
|
|
395
444
|
Get an existing AclAuthMethod resource's state with the given name, id, and optional extra
|
|
@@ -407,6 +456,9 @@ class AclAuthMethod(pulumi.CustomResource):
|
|
|
407
456
|
:param pulumi.Input[str] token_locality: `(string: <required>)` - Defines whether the ACL Auth Method
|
|
408
457
|
creates a local or global token when performing SSO login. This field must be
|
|
409
458
|
set to either `local` or `global`.
|
|
459
|
+
:param pulumi.Input[str] token_name_format: `(string: <optional>)` - Defines the token name format for the
|
|
460
|
+
generated tokens This can be lightly templated using HIL '${foo}' syntax.
|
|
461
|
+
Defaults to `${auth_method_type}-${auth_method_name}`.
|
|
410
462
|
:param pulumi.Input[str] type: `(string: <required>)` - ACL Auth Method SSO workflow type. Currently,
|
|
411
463
|
the only supported type is `OIDC`.
|
|
412
464
|
"""
|
|
@@ -419,6 +471,7 @@ class AclAuthMethod(pulumi.CustomResource):
|
|
|
419
471
|
__props__.__dict__["max_token_ttl"] = max_token_ttl
|
|
420
472
|
__props__.__dict__["name"] = name
|
|
421
473
|
__props__.__dict__["token_locality"] = token_locality
|
|
474
|
+
__props__.__dict__["token_name_format"] = token_name_format
|
|
422
475
|
__props__.__dict__["type"] = type
|
|
423
476
|
return AclAuthMethod(resource_name, opts=opts, __props__=__props__)
|
|
424
477
|
|
|
@@ -466,6 +519,16 @@ class AclAuthMethod(pulumi.CustomResource):
|
|
|
466
519
|
"""
|
|
467
520
|
return pulumi.get(self, "token_locality")
|
|
468
521
|
|
|
522
|
+
@property
|
|
523
|
+
@pulumi.getter(name="tokenNameFormat")
|
|
524
|
+
def token_name_format(self) -> pulumi.Output[Optional[str]]:
|
|
525
|
+
"""
|
|
526
|
+
`(string: <optional>)` - Defines the token name format for the
|
|
527
|
+
generated tokens This can be lightly templated using HIL '${foo}' syntax.
|
|
528
|
+
Defaults to `${auth_method_type}-${auth_method_name}`.
|
|
529
|
+
"""
|
|
530
|
+
return pulumi.get(self, "token_name_format")
|
|
531
|
+
|
|
469
532
|
@property
|
|
470
533
|
@pulumi.getter
|
|
471
534
|
def type(self) -> pulumi.Output[str]:
|
pulumi_nomad/csi_volume.py
CHANGED
|
@@ -230,12 +230,16 @@ class CsiVolumeArgs:
|
|
|
230
230
|
class _CsiVolumeState:
|
|
231
231
|
def __init__(__self__, *,
|
|
232
232
|
capabilities: Optional[pulumi.Input[Sequence[pulumi.Input['CsiVolumeCapabilityArgs']]]] = None,
|
|
233
|
+
capacity: Optional[pulumi.Input[int]] = None,
|
|
233
234
|
capacity_max: Optional[pulumi.Input[str]] = None,
|
|
235
|
+
capacity_max_bytes: Optional[pulumi.Input[int]] = None,
|
|
234
236
|
capacity_min: Optional[pulumi.Input[str]] = None,
|
|
237
|
+
capacity_min_bytes: Optional[pulumi.Input[int]] = None,
|
|
235
238
|
clone_id: Optional[pulumi.Input[str]] = None,
|
|
236
239
|
controller_required: Optional[pulumi.Input[bool]] = None,
|
|
237
240
|
controllers_expected: Optional[pulumi.Input[int]] = None,
|
|
238
241
|
controllers_healthy: Optional[pulumi.Input[int]] = None,
|
|
242
|
+
external_id: Optional[pulumi.Input[str]] = None,
|
|
239
243
|
mount_options: Optional[pulumi.Input['CsiVolumeMountOptionsArgs']] = None,
|
|
240
244
|
name: Optional[pulumi.Input[str]] = None,
|
|
241
245
|
namespace: Optional[pulumi.Input[str]] = None,
|
|
@@ -260,6 +264,7 @@ class _CsiVolumeState:
|
|
|
260
264
|
:param pulumi.Input[bool] controller_required: `(boolean)`
|
|
261
265
|
:param pulumi.Input[int] controllers_expected: `(integer)`
|
|
262
266
|
:param pulumi.Input[int] controllers_healthy: `(integer)`
|
|
267
|
+
:param pulumi.Input[str] external_id: The ID of the physical volume from the storage provider.
|
|
263
268
|
:param pulumi.Input['CsiVolumeMountOptionsArgs'] mount_options: `(block: optional)` Options for mounting `block-device` volumes without a pre-formatted file system.
|
|
264
269
|
:param pulumi.Input[str] name: `(string: <required>)` - The display name for the volume.
|
|
265
270
|
:param pulumi.Input[str] namespace: `(string: "default")` - The namespace in which to register the volume.
|
|
@@ -278,10 +283,16 @@ class _CsiVolumeState:
|
|
|
278
283
|
"""
|
|
279
284
|
if capabilities is not None:
|
|
280
285
|
pulumi.set(__self__, "capabilities", capabilities)
|
|
286
|
+
if capacity is not None:
|
|
287
|
+
pulumi.set(__self__, "capacity", capacity)
|
|
281
288
|
if capacity_max is not None:
|
|
282
289
|
pulumi.set(__self__, "capacity_max", capacity_max)
|
|
290
|
+
if capacity_max_bytes is not None:
|
|
291
|
+
pulumi.set(__self__, "capacity_max_bytes", capacity_max_bytes)
|
|
283
292
|
if capacity_min is not None:
|
|
284
293
|
pulumi.set(__self__, "capacity_min", capacity_min)
|
|
294
|
+
if capacity_min_bytes is not None:
|
|
295
|
+
pulumi.set(__self__, "capacity_min_bytes", capacity_min_bytes)
|
|
285
296
|
if clone_id is not None:
|
|
286
297
|
pulumi.set(__self__, "clone_id", clone_id)
|
|
287
298
|
if controller_required is not None:
|
|
@@ -290,6 +301,8 @@ class _CsiVolumeState:
|
|
|
290
301
|
pulumi.set(__self__, "controllers_expected", controllers_expected)
|
|
291
302
|
if controllers_healthy is not None:
|
|
292
303
|
pulumi.set(__self__, "controllers_healthy", controllers_healthy)
|
|
304
|
+
if external_id is not None:
|
|
305
|
+
pulumi.set(__self__, "external_id", external_id)
|
|
293
306
|
if mount_options is not None:
|
|
294
307
|
pulumi.set(__self__, "mount_options", mount_options)
|
|
295
308
|
if name is not None:
|
|
@@ -333,6 +346,15 @@ class _CsiVolumeState:
|
|
|
333
346
|
def capabilities(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['CsiVolumeCapabilityArgs']]]]):
|
|
334
347
|
pulumi.set(self, "capabilities", value)
|
|
335
348
|
|
|
349
|
+
@property
|
|
350
|
+
@pulumi.getter
|
|
351
|
+
def capacity(self) -> Optional[pulumi.Input[int]]:
|
|
352
|
+
return pulumi.get(self, "capacity")
|
|
353
|
+
|
|
354
|
+
@capacity.setter
|
|
355
|
+
def capacity(self, value: Optional[pulumi.Input[int]]):
|
|
356
|
+
pulumi.set(self, "capacity", value)
|
|
357
|
+
|
|
336
358
|
@property
|
|
337
359
|
@pulumi.getter(name="capacityMax")
|
|
338
360
|
def capacity_max(self) -> Optional[pulumi.Input[str]]:
|
|
@@ -345,6 +367,15 @@ class _CsiVolumeState:
|
|
|
345
367
|
def capacity_max(self, value: Optional[pulumi.Input[str]]):
|
|
346
368
|
pulumi.set(self, "capacity_max", value)
|
|
347
369
|
|
|
370
|
+
@property
|
|
371
|
+
@pulumi.getter(name="capacityMaxBytes")
|
|
372
|
+
def capacity_max_bytes(self) -> Optional[pulumi.Input[int]]:
|
|
373
|
+
return pulumi.get(self, "capacity_max_bytes")
|
|
374
|
+
|
|
375
|
+
@capacity_max_bytes.setter
|
|
376
|
+
def capacity_max_bytes(self, value: Optional[pulumi.Input[int]]):
|
|
377
|
+
pulumi.set(self, "capacity_max_bytes", value)
|
|
378
|
+
|
|
348
379
|
@property
|
|
349
380
|
@pulumi.getter(name="capacityMin")
|
|
350
381
|
def capacity_min(self) -> Optional[pulumi.Input[str]]:
|
|
@@ -357,6 +388,15 @@ class _CsiVolumeState:
|
|
|
357
388
|
def capacity_min(self, value: Optional[pulumi.Input[str]]):
|
|
358
389
|
pulumi.set(self, "capacity_min", value)
|
|
359
390
|
|
|
391
|
+
@property
|
|
392
|
+
@pulumi.getter(name="capacityMinBytes")
|
|
393
|
+
def capacity_min_bytes(self) -> Optional[pulumi.Input[int]]:
|
|
394
|
+
return pulumi.get(self, "capacity_min_bytes")
|
|
395
|
+
|
|
396
|
+
@capacity_min_bytes.setter
|
|
397
|
+
def capacity_min_bytes(self, value: Optional[pulumi.Input[int]]):
|
|
398
|
+
pulumi.set(self, "capacity_min_bytes", value)
|
|
399
|
+
|
|
360
400
|
@property
|
|
361
401
|
@pulumi.getter(name="cloneId")
|
|
362
402
|
def clone_id(self) -> Optional[pulumi.Input[str]]:
|
|
@@ -405,6 +445,18 @@ class _CsiVolumeState:
|
|
|
405
445
|
def controllers_healthy(self, value: Optional[pulumi.Input[int]]):
|
|
406
446
|
pulumi.set(self, "controllers_healthy", value)
|
|
407
447
|
|
|
448
|
+
@property
|
|
449
|
+
@pulumi.getter(name="externalId")
|
|
450
|
+
def external_id(self) -> Optional[pulumi.Input[str]]:
|
|
451
|
+
"""
|
|
452
|
+
The ID of the physical volume from the storage provider.
|
|
453
|
+
"""
|
|
454
|
+
return pulumi.get(self, "external_id")
|
|
455
|
+
|
|
456
|
+
@external_id.setter
|
|
457
|
+
def external_id(self, value: Optional[pulumi.Input[str]]):
|
|
458
|
+
pulumi.set(self, "external_id", value)
|
|
459
|
+
|
|
408
460
|
@property
|
|
409
461
|
@pulumi.getter(name="mountOptions")
|
|
410
462
|
def mount_options(self) -> Optional[pulumi.Input['CsiVolumeMountOptionsArgs']]:
|
|
@@ -606,48 +658,7 @@ class CsiVolume(pulumi.CustomResource):
|
|
|
606
658
|
volume_id: Optional[pulumi.Input[str]] = None,
|
|
607
659
|
__props__=None):
|
|
608
660
|
"""
|
|
609
|
-
|
|
610
|
-
|
|
611
|
-
Creating a volume:
|
|
612
|
-
|
|
613
|
-
```python
|
|
614
|
-
import pulumi
|
|
615
|
-
import pulumi_nomad as nomad
|
|
616
|
-
|
|
617
|
-
ebs = nomad.get_plugin(plugin_id="aws-ebs0",
|
|
618
|
-
wait_for_healthy=True)
|
|
619
|
-
mysql_volume = nomad.CsiVolume("mysqlVolume",
|
|
620
|
-
plugin_id="aws-ebs0",
|
|
621
|
-
volume_id="mysql_volume",
|
|
622
|
-
capacity_min="10GiB",
|
|
623
|
-
capacity_max="20GiB",
|
|
624
|
-
capabilities=[nomad.CsiVolumeCapabilityArgs(
|
|
625
|
-
access_mode="single-node-writer",
|
|
626
|
-
attachment_mode="file-system",
|
|
627
|
-
)],
|
|
628
|
-
mount_options=nomad.CsiVolumeMountOptionsArgs(
|
|
629
|
-
fs_type="ext4",
|
|
630
|
-
),
|
|
631
|
-
topology_request=nomad.CsiVolumeTopologyRequestArgs(
|
|
632
|
-
required=nomad.CsiVolumeTopologyRequestRequiredArgs(
|
|
633
|
-
topologies=[
|
|
634
|
-
nomad.CsiVolumeTopologyRequestRequiredTopologyArgs(
|
|
635
|
-
segments={
|
|
636
|
-
"rack": "R1",
|
|
637
|
-
"zone": "us-east-1a",
|
|
638
|
-
},
|
|
639
|
-
),
|
|
640
|
-
nomad.CsiVolumeTopologyRequestRequiredTopologyArgs(
|
|
641
|
-
segments={
|
|
642
|
-
"rack": "R2",
|
|
643
|
-
},
|
|
644
|
-
),
|
|
645
|
-
],
|
|
646
|
-
),
|
|
647
|
-
),
|
|
648
|
-
opts=pulumi.ResourceOptions(depends_on=[ebs]))
|
|
649
|
-
```
|
|
650
|
-
|
|
661
|
+
Create a CsiVolume resource with the given unique name, props, and options.
|
|
651
662
|
:param str resource_name: The name of the resource.
|
|
652
663
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
653
664
|
:param pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['CsiVolumeCapabilityArgs']]]] capabilities: `(``Capability``: <required>)` - Options for validating the capability of a volume.
|
|
@@ -671,48 +682,7 @@ class CsiVolume(pulumi.CustomResource):
|
|
|
671
682
|
args: CsiVolumeArgs,
|
|
672
683
|
opts: Optional[pulumi.ResourceOptions] = None):
|
|
673
684
|
"""
|
|
674
|
-
|
|
675
|
-
|
|
676
|
-
Creating a volume:
|
|
677
|
-
|
|
678
|
-
```python
|
|
679
|
-
import pulumi
|
|
680
|
-
import pulumi_nomad as nomad
|
|
681
|
-
|
|
682
|
-
ebs = nomad.get_plugin(plugin_id="aws-ebs0",
|
|
683
|
-
wait_for_healthy=True)
|
|
684
|
-
mysql_volume = nomad.CsiVolume("mysqlVolume",
|
|
685
|
-
plugin_id="aws-ebs0",
|
|
686
|
-
volume_id="mysql_volume",
|
|
687
|
-
capacity_min="10GiB",
|
|
688
|
-
capacity_max="20GiB",
|
|
689
|
-
capabilities=[nomad.CsiVolumeCapabilityArgs(
|
|
690
|
-
access_mode="single-node-writer",
|
|
691
|
-
attachment_mode="file-system",
|
|
692
|
-
)],
|
|
693
|
-
mount_options=nomad.CsiVolumeMountOptionsArgs(
|
|
694
|
-
fs_type="ext4",
|
|
695
|
-
),
|
|
696
|
-
topology_request=nomad.CsiVolumeTopologyRequestArgs(
|
|
697
|
-
required=nomad.CsiVolumeTopologyRequestRequiredArgs(
|
|
698
|
-
topologies=[
|
|
699
|
-
nomad.CsiVolumeTopologyRequestRequiredTopologyArgs(
|
|
700
|
-
segments={
|
|
701
|
-
"rack": "R1",
|
|
702
|
-
"zone": "us-east-1a",
|
|
703
|
-
},
|
|
704
|
-
),
|
|
705
|
-
nomad.CsiVolumeTopologyRequestRequiredTopologyArgs(
|
|
706
|
-
segments={
|
|
707
|
-
"rack": "R2",
|
|
708
|
-
},
|
|
709
|
-
),
|
|
710
|
-
],
|
|
711
|
-
),
|
|
712
|
-
),
|
|
713
|
-
opts=pulumi.ResourceOptions(depends_on=[ebs]))
|
|
714
|
-
```
|
|
715
|
-
|
|
685
|
+
Create a CsiVolume resource with the given unique name, props, and options.
|
|
716
686
|
:param str resource_name: The name of the resource.
|
|
717
687
|
:param CsiVolumeArgs args: The arguments to use to populate this resource's properties.
|
|
718
688
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
@@ -769,9 +739,13 @@ class CsiVolume(pulumi.CustomResource):
|
|
|
769
739
|
if volume_id is None and not opts.urn:
|
|
770
740
|
raise TypeError("Missing required property 'volume_id'")
|
|
771
741
|
__props__.__dict__["volume_id"] = volume_id
|
|
742
|
+
__props__.__dict__["capacity"] = None
|
|
743
|
+
__props__.__dict__["capacity_max_bytes"] = None
|
|
744
|
+
__props__.__dict__["capacity_min_bytes"] = None
|
|
772
745
|
__props__.__dict__["controller_required"] = None
|
|
773
746
|
__props__.__dict__["controllers_expected"] = None
|
|
774
747
|
__props__.__dict__["controllers_healthy"] = None
|
|
748
|
+
__props__.__dict__["external_id"] = None
|
|
775
749
|
__props__.__dict__["nodes_expected"] = None
|
|
776
750
|
__props__.__dict__["nodes_healthy"] = None
|
|
777
751
|
__props__.__dict__["plugin_provider"] = None
|
|
@@ -791,12 +765,16 @@ class CsiVolume(pulumi.CustomResource):
|
|
|
791
765
|
id: pulumi.Input[str],
|
|
792
766
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
793
767
|
capabilities: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['CsiVolumeCapabilityArgs']]]]] = None,
|
|
768
|
+
capacity: Optional[pulumi.Input[int]] = None,
|
|
794
769
|
capacity_max: Optional[pulumi.Input[str]] = None,
|
|
770
|
+
capacity_max_bytes: Optional[pulumi.Input[int]] = None,
|
|
795
771
|
capacity_min: Optional[pulumi.Input[str]] = None,
|
|
772
|
+
capacity_min_bytes: Optional[pulumi.Input[int]] = None,
|
|
796
773
|
clone_id: Optional[pulumi.Input[str]] = None,
|
|
797
774
|
controller_required: Optional[pulumi.Input[bool]] = None,
|
|
798
775
|
controllers_expected: Optional[pulumi.Input[int]] = None,
|
|
799
776
|
controllers_healthy: Optional[pulumi.Input[int]] = None,
|
|
777
|
+
external_id: Optional[pulumi.Input[str]] = None,
|
|
800
778
|
mount_options: Optional[pulumi.Input[pulumi.InputType['CsiVolumeMountOptionsArgs']]] = None,
|
|
801
779
|
name: Optional[pulumi.Input[str]] = None,
|
|
802
780
|
namespace: Optional[pulumi.Input[str]] = None,
|
|
@@ -826,6 +804,7 @@ class CsiVolume(pulumi.CustomResource):
|
|
|
826
804
|
:param pulumi.Input[bool] controller_required: `(boolean)`
|
|
827
805
|
:param pulumi.Input[int] controllers_expected: `(integer)`
|
|
828
806
|
:param pulumi.Input[int] controllers_healthy: `(integer)`
|
|
807
|
+
:param pulumi.Input[str] external_id: The ID of the physical volume from the storage provider.
|
|
829
808
|
:param pulumi.Input[pulumi.InputType['CsiVolumeMountOptionsArgs']] mount_options: `(block: optional)` Options for mounting `block-device` volumes without a pre-formatted file system.
|
|
830
809
|
:param pulumi.Input[str] name: `(string: <required>)` - The display name for the volume.
|
|
831
810
|
:param pulumi.Input[str] namespace: `(string: "default")` - The namespace in which to register the volume.
|
|
@@ -847,12 +826,16 @@ class CsiVolume(pulumi.CustomResource):
|
|
|
847
826
|
__props__ = _CsiVolumeState.__new__(_CsiVolumeState)
|
|
848
827
|
|
|
849
828
|
__props__.__dict__["capabilities"] = capabilities
|
|
829
|
+
__props__.__dict__["capacity"] = capacity
|
|
850
830
|
__props__.__dict__["capacity_max"] = capacity_max
|
|
831
|
+
__props__.__dict__["capacity_max_bytes"] = capacity_max_bytes
|
|
851
832
|
__props__.__dict__["capacity_min"] = capacity_min
|
|
833
|
+
__props__.__dict__["capacity_min_bytes"] = capacity_min_bytes
|
|
852
834
|
__props__.__dict__["clone_id"] = clone_id
|
|
853
835
|
__props__.__dict__["controller_required"] = controller_required
|
|
854
836
|
__props__.__dict__["controllers_expected"] = controllers_expected
|
|
855
837
|
__props__.__dict__["controllers_healthy"] = controllers_healthy
|
|
838
|
+
__props__.__dict__["external_id"] = external_id
|
|
856
839
|
__props__.__dict__["mount_options"] = mount_options
|
|
857
840
|
__props__.__dict__["name"] = name
|
|
858
841
|
__props__.__dict__["namespace"] = namespace
|
|
@@ -878,6 +861,11 @@ class CsiVolume(pulumi.CustomResource):
|
|
|
878
861
|
"""
|
|
879
862
|
return pulumi.get(self, "capabilities")
|
|
880
863
|
|
|
864
|
+
@property
|
|
865
|
+
@pulumi.getter
|
|
866
|
+
def capacity(self) -> pulumi.Output[int]:
|
|
867
|
+
return pulumi.get(self, "capacity")
|
|
868
|
+
|
|
881
869
|
@property
|
|
882
870
|
@pulumi.getter(name="capacityMax")
|
|
883
871
|
def capacity_max(self) -> pulumi.Output[Optional[str]]:
|
|
@@ -886,6 +874,11 @@ class CsiVolume(pulumi.CustomResource):
|
|
|
886
874
|
"""
|
|
887
875
|
return pulumi.get(self, "capacity_max")
|
|
888
876
|
|
|
877
|
+
@property
|
|
878
|
+
@pulumi.getter(name="capacityMaxBytes")
|
|
879
|
+
def capacity_max_bytes(self) -> pulumi.Output[int]:
|
|
880
|
+
return pulumi.get(self, "capacity_max_bytes")
|
|
881
|
+
|
|
889
882
|
@property
|
|
890
883
|
@pulumi.getter(name="capacityMin")
|
|
891
884
|
def capacity_min(self) -> pulumi.Output[Optional[str]]:
|
|
@@ -894,6 +887,11 @@ class CsiVolume(pulumi.CustomResource):
|
|
|
894
887
|
"""
|
|
895
888
|
return pulumi.get(self, "capacity_min")
|
|
896
889
|
|
|
890
|
+
@property
|
|
891
|
+
@pulumi.getter(name="capacityMinBytes")
|
|
892
|
+
def capacity_min_bytes(self) -> pulumi.Output[int]:
|
|
893
|
+
return pulumi.get(self, "capacity_min_bytes")
|
|
894
|
+
|
|
897
895
|
@property
|
|
898
896
|
@pulumi.getter(name="cloneId")
|
|
899
897
|
def clone_id(self) -> pulumi.Output[Optional[str]]:
|
|
@@ -926,6 +924,14 @@ class CsiVolume(pulumi.CustomResource):
|
|
|
926
924
|
"""
|
|
927
925
|
return pulumi.get(self, "controllers_healthy")
|
|
928
926
|
|
|
927
|
+
@property
|
|
928
|
+
@pulumi.getter(name="externalId")
|
|
929
|
+
def external_id(self) -> pulumi.Output[str]:
|
|
930
|
+
"""
|
|
931
|
+
The ID of the physical volume from the storage provider.
|
|
932
|
+
"""
|
|
933
|
+
return pulumi.get(self, "external_id")
|
|
934
|
+
|
|
929
935
|
@property
|
|
930
936
|
@pulumi.getter(name="mountOptions")
|
|
931
937
|
def mount_options(self) -> pulumi.Output[Optional['outputs.CsiVolumeMountOptions']]:
|
|
@@ -20,6 +20,8 @@ class CsiVolumeRegistrationArgs:
|
|
|
20
20
|
plugin_id: pulumi.Input[str],
|
|
21
21
|
volume_id: pulumi.Input[str],
|
|
22
22
|
capabilities: Optional[pulumi.Input[Sequence[pulumi.Input['CsiVolumeRegistrationCapabilityArgs']]]] = None,
|
|
23
|
+
capacity_max: Optional[pulumi.Input[str]] = None,
|
|
24
|
+
capacity_min: Optional[pulumi.Input[str]] = None,
|
|
23
25
|
context: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
24
26
|
deregister_on_destroy: Optional[pulumi.Input[bool]] = None,
|
|
25
27
|
mount_options: Optional[pulumi.Input['CsiVolumeRegistrationMountOptionsArgs']] = None,
|
|
@@ -34,6 +36,8 @@ class CsiVolumeRegistrationArgs:
|
|
|
34
36
|
:param pulumi.Input[str] plugin_id: `(string: <required>)` - The ID of the Nomad plugin for registering this volume.
|
|
35
37
|
:param pulumi.Input[str] volume_id: `(string: <required>)` - The unique ID of the volume.
|
|
36
38
|
:param pulumi.Input[Sequence[pulumi.Input['CsiVolumeRegistrationCapabilityArgs']]] capabilities: `(``Capability``: <required>)` - Options for validating the capability of a volume.
|
|
39
|
+
:param pulumi.Input[str] capacity_max: `(string: <optional>)` - Option to signal a maximum volume size. This may not be supported by all storage providers.
|
|
40
|
+
:param pulumi.Input[str] capacity_min: `(string: <optional>)` - Option to signal a minimum volume size. This may not be supported by all storage providers.
|
|
37
41
|
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] context: `(map[string]string: <optional>)` - An optional key-value map of strings passed directly to the CSI plugin to validate the volume.
|
|
38
42
|
:param pulumi.Input[bool] deregister_on_destroy: `(boolean: false)` - If true, the volume will be deregistered on destroy.
|
|
39
43
|
:param pulumi.Input['CsiVolumeRegistrationMountOptionsArgs'] mount_options: `(block: <optional>)` Options for mounting `block-device` volumes without a pre-formatted file system.
|
|
@@ -48,6 +52,10 @@ class CsiVolumeRegistrationArgs:
|
|
|
48
52
|
pulumi.set(__self__, "volume_id", volume_id)
|
|
49
53
|
if capabilities is not None:
|
|
50
54
|
pulumi.set(__self__, "capabilities", capabilities)
|
|
55
|
+
if capacity_max is not None:
|
|
56
|
+
pulumi.set(__self__, "capacity_max", capacity_max)
|
|
57
|
+
if capacity_min is not None:
|
|
58
|
+
pulumi.set(__self__, "capacity_min", capacity_min)
|
|
51
59
|
if context is not None:
|
|
52
60
|
pulumi.set(__self__, "context", context)
|
|
53
61
|
if deregister_on_destroy is not None:
|
|
@@ -113,6 +121,30 @@ class CsiVolumeRegistrationArgs:
|
|
|
113
121
|
def capabilities(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['CsiVolumeRegistrationCapabilityArgs']]]]):
|
|
114
122
|
pulumi.set(self, "capabilities", value)
|
|
115
123
|
|
|
124
|
+
@property
|
|
125
|
+
@pulumi.getter(name="capacityMax")
|
|
126
|
+
def capacity_max(self) -> Optional[pulumi.Input[str]]:
|
|
127
|
+
"""
|
|
128
|
+
`(string: <optional>)` - Option to signal a maximum volume size. This may not be supported by all storage providers.
|
|
129
|
+
"""
|
|
130
|
+
return pulumi.get(self, "capacity_max")
|
|
131
|
+
|
|
132
|
+
@capacity_max.setter
|
|
133
|
+
def capacity_max(self, value: Optional[pulumi.Input[str]]):
|
|
134
|
+
pulumi.set(self, "capacity_max", value)
|
|
135
|
+
|
|
136
|
+
@property
|
|
137
|
+
@pulumi.getter(name="capacityMin")
|
|
138
|
+
def capacity_min(self) -> Optional[pulumi.Input[str]]:
|
|
139
|
+
"""
|
|
140
|
+
`(string: <optional>)` - Option to signal a minimum volume size. This may not be supported by all storage providers.
|
|
141
|
+
"""
|
|
142
|
+
return pulumi.get(self, "capacity_min")
|
|
143
|
+
|
|
144
|
+
@capacity_min.setter
|
|
145
|
+
def capacity_min(self, value: Optional[pulumi.Input[str]]):
|
|
146
|
+
pulumi.set(self, "capacity_min", value)
|
|
147
|
+
|
|
116
148
|
@property
|
|
117
149
|
@pulumi.getter
|
|
118
150
|
def context(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
@@ -214,6 +246,11 @@ class CsiVolumeRegistrationArgs:
|
|
|
214
246
|
class _CsiVolumeRegistrationState:
|
|
215
247
|
def __init__(__self__, *,
|
|
216
248
|
capabilities: Optional[pulumi.Input[Sequence[pulumi.Input['CsiVolumeRegistrationCapabilityArgs']]]] = None,
|
|
249
|
+
capacity: Optional[pulumi.Input[int]] = None,
|
|
250
|
+
capacity_max: Optional[pulumi.Input[str]] = None,
|
|
251
|
+
capacity_max_bytes: Optional[pulumi.Input[int]] = None,
|
|
252
|
+
capacity_min: Optional[pulumi.Input[str]] = None,
|
|
253
|
+
capacity_min_bytes: Optional[pulumi.Input[int]] = None,
|
|
217
254
|
context: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
218
255
|
controller_required: Optional[pulumi.Input[bool]] = None,
|
|
219
256
|
controllers_expected: Optional[pulumi.Input[int]] = None,
|
|
@@ -237,6 +274,8 @@ class _CsiVolumeRegistrationState:
|
|
|
237
274
|
"""
|
|
238
275
|
Input properties used for looking up and filtering CsiVolumeRegistration resources.
|
|
239
276
|
:param pulumi.Input[Sequence[pulumi.Input['CsiVolumeRegistrationCapabilityArgs']]] capabilities: `(``Capability``: <required>)` - Options for validating the capability of a volume.
|
|
277
|
+
:param pulumi.Input[str] capacity_max: `(string: <optional>)` - Option to signal a maximum volume size. This may not be supported by all storage providers.
|
|
278
|
+
:param pulumi.Input[str] capacity_min: `(string: <optional>)` - Option to signal a minimum volume size. This may not be supported by all storage providers.
|
|
240
279
|
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] context: `(map[string]string: <optional>)` - An optional key-value map of strings passed directly to the CSI plugin to validate the volume.
|
|
241
280
|
:param pulumi.Input[bool] controller_required: `(boolean)`
|
|
242
281
|
:param pulumi.Input[int] controllers_expected: `(integer)`
|
|
@@ -260,6 +299,16 @@ class _CsiVolumeRegistrationState:
|
|
|
260
299
|
"""
|
|
261
300
|
if capabilities is not None:
|
|
262
301
|
pulumi.set(__self__, "capabilities", capabilities)
|
|
302
|
+
if capacity is not None:
|
|
303
|
+
pulumi.set(__self__, "capacity", capacity)
|
|
304
|
+
if capacity_max is not None:
|
|
305
|
+
pulumi.set(__self__, "capacity_max", capacity_max)
|
|
306
|
+
if capacity_max_bytes is not None:
|
|
307
|
+
pulumi.set(__self__, "capacity_max_bytes", capacity_max_bytes)
|
|
308
|
+
if capacity_min is not None:
|
|
309
|
+
pulumi.set(__self__, "capacity_min", capacity_min)
|
|
310
|
+
if capacity_min_bytes is not None:
|
|
311
|
+
pulumi.set(__self__, "capacity_min_bytes", capacity_min_bytes)
|
|
263
312
|
if context is not None:
|
|
264
313
|
pulumi.set(__self__, "context", context)
|
|
265
314
|
if controller_required is not None:
|
|
@@ -313,6 +362,57 @@ class _CsiVolumeRegistrationState:
|
|
|
313
362
|
def capabilities(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['CsiVolumeRegistrationCapabilityArgs']]]]):
|
|
314
363
|
pulumi.set(self, "capabilities", value)
|
|
315
364
|
|
|
365
|
+
@property
|
|
366
|
+
@pulumi.getter
|
|
367
|
+
def capacity(self) -> Optional[pulumi.Input[int]]:
|
|
368
|
+
return pulumi.get(self, "capacity")
|
|
369
|
+
|
|
370
|
+
@capacity.setter
|
|
371
|
+
def capacity(self, value: Optional[pulumi.Input[int]]):
|
|
372
|
+
pulumi.set(self, "capacity", value)
|
|
373
|
+
|
|
374
|
+
@property
|
|
375
|
+
@pulumi.getter(name="capacityMax")
|
|
376
|
+
def capacity_max(self) -> Optional[pulumi.Input[str]]:
|
|
377
|
+
"""
|
|
378
|
+
`(string: <optional>)` - Option to signal a maximum volume size. This may not be supported by all storage providers.
|
|
379
|
+
"""
|
|
380
|
+
return pulumi.get(self, "capacity_max")
|
|
381
|
+
|
|
382
|
+
@capacity_max.setter
|
|
383
|
+
def capacity_max(self, value: Optional[pulumi.Input[str]]):
|
|
384
|
+
pulumi.set(self, "capacity_max", value)
|
|
385
|
+
|
|
386
|
+
@property
|
|
387
|
+
@pulumi.getter(name="capacityMaxBytes")
|
|
388
|
+
def capacity_max_bytes(self) -> Optional[pulumi.Input[int]]:
|
|
389
|
+
return pulumi.get(self, "capacity_max_bytes")
|
|
390
|
+
|
|
391
|
+
@capacity_max_bytes.setter
|
|
392
|
+
def capacity_max_bytes(self, value: Optional[pulumi.Input[int]]):
|
|
393
|
+
pulumi.set(self, "capacity_max_bytes", value)
|
|
394
|
+
|
|
395
|
+
@property
|
|
396
|
+
@pulumi.getter(name="capacityMin")
|
|
397
|
+
def capacity_min(self) -> Optional[pulumi.Input[str]]:
|
|
398
|
+
"""
|
|
399
|
+
`(string: <optional>)` - Option to signal a minimum volume size. This may not be supported by all storage providers.
|
|
400
|
+
"""
|
|
401
|
+
return pulumi.get(self, "capacity_min")
|
|
402
|
+
|
|
403
|
+
@capacity_min.setter
|
|
404
|
+
def capacity_min(self, value: Optional[pulumi.Input[str]]):
|
|
405
|
+
pulumi.set(self, "capacity_min", value)
|
|
406
|
+
|
|
407
|
+
@property
|
|
408
|
+
@pulumi.getter(name="capacityMinBytes")
|
|
409
|
+
def capacity_min_bytes(self) -> Optional[pulumi.Input[int]]:
|
|
410
|
+
return pulumi.get(self, "capacity_min_bytes")
|
|
411
|
+
|
|
412
|
+
@capacity_min_bytes.setter
|
|
413
|
+
def capacity_min_bytes(self, value: Optional[pulumi.Input[int]]):
|
|
414
|
+
pulumi.set(self, "capacity_min_bytes", value)
|
|
415
|
+
|
|
316
416
|
@property
|
|
317
417
|
@pulumi.getter
|
|
318
418
|
def context(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
@@ -560,6 +660,8 @@ class CsiVolumeRegistration(pulumi.CustomResource):
|
|
|
560
660
|
resource_name: str,
|
|
561
661
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
562
662
|
capabilities: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['CsiVolumeRegistrationCapabilityArgs']]]]] = None,
|
|
663
|
+
capacity_max: Optional[pulumi.Input[str]] = None,
|
|
664
|
+
capacity_min: Optional[pulumi.Input[str]] = None,
|
|
563
665
|
context: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
564
666
|
deregister_on_destroy: Optional[pulumi.Input[bool]] = None,
|
|
565
667
|
external_id: Optional[pulumi.Input[str]] = None,
|
|
@@ -573,50 +675,12 @@ class CsiVolumeRegistration(pulumi.CustomResource):
|
|
|
573
675
|
volume_id: Optional[pulumi.Input[str]] = None,
|
|
574
676
|
__props__=None):
|
|
575
677
|
"""
|
|
576
|
-
|
|
577
|
-
|
|
578
|
-
Registering a volume:
|
|
579
|
-
|
|
580
|
-
```python
|
|
581
|
-
import pulumi
|
|
582
|
-
import pulumi_nomad as nomad
|
|
583
|
-
|
|
584
|
-
ebs = nomad.get_plugin(plugin_id="aws-ebs0",
|
|
585
|
-
wait_for_healthy=True)
|
|
586
|
-
mysql_volume = nomad.Volume("mysqlVolume",
|
|
587
|
-
plugin_id="aws-ebs0",
|
|
588
|
-
volume_id="mysql_volume",
|
|
589
|
-
external_id=module["hashistack"]["ebs_test_volume_id"],
|
|
590
|
-
capabilities=[nomad.VolumeCapabilityArgs(
|
|
591
|
-
access_mode="single-node-writer",
|
|
592
|
-
attachment_mode="file-system",
|
|
593
|
-
)],
|
|
594
|
-
mount_options=nomad.VolumeMountOptionsArgs(
|
|
595
|
-
fs_type="ext4",
|
|
596
|
-
),
|
|
597
|
-
topology_request=nomad.VolumeTopologyRequestArgs(
|
|
598
|
-
required=nomad.VolumeTopologyRequestRequiredArgs(
|
|
599
|
-
topologies=[
|
|
600
|
-
nomad.VolumeTopologyRequestRequiredTopologyArgs(
|
|
601
|
-
segments={
|
|
602
|
-
"rack": "R1",
|
|
603
|
-
"zone": "us-east-1a",
|
|
604
|
-
},
|
|
605
|
-
),
|
|
606
|
-
nomad.VolumeTopologyRequestRequiredTopologyArgs(
|
|
607
|
-
segments={
|
|
608
|
-
"rack": "R2",
|
|
609
|
-
},
|
|
610
|
-
),
|
|
611
|
-
],
|
|
612
|
-
),
|
|
613
|
-
),
|
|
614
|
-
opts=pulumi.ResourceOptions(depends_on=[ebs]))
|
|
615
|
-
```
|
|
616
|
-
|
|
678
|
+
Create a CsiVolumeRegistration resource with the given unique name, props, and options.
|
|
617
679
|
:param str resource_name: The name of the resource.
|
|
618
680
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
619
681
|
:param pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['CsiVolumeRegistrationCapabilityArgs']]]] capabilities: `(``Capability``: <required>)` - Options for validating the capability of a volume.
|
|
682
|
+
:param pulumi.Input[str] capacity_max: `(string: <optional>)` - Option to signal a maximum volume size. This may not be supported by all storage providers.
|
|
683
|
+
:param pulumi.Input[str] capacity_min: `(string: <optional>)` - Option to signal a minimum volume size. This may not be supported by all storage providers.
|
|
620
684
|
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] context: `(map[string]string: <optional>)` - An optional key-value map of strings passed directly to the CSI plugin to validate the volume.
|
|
621
685
|
:param pulumi.Input[bool] deregister_on_destroy: `(boolean: false)` - If true, the volume will be deregistered on destroy.
|
|
622
686
|
:param pulumi.Input[str] external_id: `(string: <required>)` - The ID of the physical volume from the storage provider.
|
|
@@ -636,47 +700,7 @@ class CsiVolumeRegistration(pulumi.CustomResource):
|
|
|
636
700
|
args: CsiVolumeRegistrationArgs,
|
|
637
701
|
opts: Optional[pulumi.ResourceOptions] = None):
|
|
638
702
|
"""
|
|
639
|
-
|
|
640
|
-
|
|
641
|
-
Registering a volume:
|
|
642
|
-
|
|
643
|
-
```python
|
|
644
|
-
import pulumi
|
|
645
|
-
import pulumi_nomad as nomad
|
|
646
|
-
|
|
647
|
-
ebs = nomad.get_plugin(plugin_id="aws-ebs0",
|
|
648
|
-
wait_for_healthy=True)
|
|
649
|
-
mysql_volume = nomad.Volume("mysqlVolume",
|
|
650
|
-
plugin_id="aws-ebs0",
|
|
651
|
-
volume_id="mysql_volume",
|
|
652
|
-
external_id=module["hashistack"]["ebs_test_volume_id"],
|
|
653
|
-
capabilities=[nomad.VolumeCapabilityArgs(
|
|
654
|
-
access_mode="single-node-writer",
|
|
655
|
-
attachment_mode="file-system",
|
|
656
|
-
)],
|
|
657
|
-
mount_options=nomad.VolumeMountOptionsArgs(
|
|
658
|
-
fs_type="ext4",
|
|
659
|
-
),
|
|
660
|
-
topology_request=nomad.VolumeTopologyRequestArgs(
|
|
661
|
-
required=nomad.VolumeTopologyRequestRequiredArgs(
|
|
662
|
-
topologies=[
|
|
663
|
-
nomad.VolumeTopologyRequestRequiredTopologyArgs(
|
|
664
|
-
segments={
|
|
665
|
-
"rack": "R1",
|
|
666
|
-
"zone": "us-east-1a",
|
|
667
|
-
},
|
|
668
|
-
),
|
|
669
|
-
nomad.VolumeTopologyRequestRequiredTopologyArgs(
|
|
670
|
-
segments={
|
|
671
|
-
"rack": "R2",
|
|
672
|
-
},
|
|
673
|
-
),
|
|
674
|
-
],
|
|
675
|
-
),
|
|
676
|
-
),
|
|
677
|
-
opts=pulumi.ResourceOptions(depends_on=[ebs]))
|
|
678
|
-
```
|
|
679
|
-
|
|
703
|
+
Create a CsiVolumeRegistration resource with the given unique name, props, and options.
|
|
680
704
|
:param str resource_name: The name of the resource.
|
|
681
705
|
:param CsiVolumeRegistrationArgs args: The arguments to use to populate this resource's properties.
|
|
682
706
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
@@ -693,6 +717,8 @@ class CsiVolumeRegistration(pulumi.CustomResource):
|
|
|
693
717
|
resource_name: str,
|
|
694
718
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
695
719
|
capabilities: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['CsiVolumeRegistrationCapabilityArgs']]]]] = None,
|
|
720
|
+
capacity_max: Optional[pulumi.Input[str]] = None,
|
|
721
|
+
capacity_min: Optional[pulumi.Input[str]] = None,
|
|
696
722
|
context: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
697
723
|
deregister_on_destroy: Optional[pulumi.Input[bool]] = None,
|
|
698
724
|
external_id: Optional[pulumi.Input[str]] = None,
|
|
@@ -714,6 +740,8 @@ class CsiVolumeRegistration(pulumi.CustomResource):
|
|
|
714
740
|
__props__ = CsiVolumeRegistrationArgs.__new__(CsiVolumeRegistrationArgs)
|
|
715
741
|
|
|
716
742
|
__props__.__dict__["capabilities"] = capabilities
|
|
743
|
+
__props__.__dict__["capacity_max"] = capacity_max
|
|
744
|
+
__props__.__dict__["capacity_min"] = capacity_min
|
|
717
745
|
__props__.__dict__["context"] = context
|
|
718
746
|
__props__.__dict__["deregister_on_destroy"] = deregister_on_destroy
|
|
719
747
|
if external_id is None and not opts.urn:
|
|
@@ -731,6 +759,9 @@ class CsiVolumeRegistration(pulumi.CustomResource):
|
|
|
731
759
|
if volume_id is None and not opts.urn:
|
|
732
760
|
raise TypeError("Missing required property 'volume_id'")
|
|
733
761
|
__props__.__dict__["volume_id"] = volume_id
|
|
762
|
+
__props__.__dict__["capacity"] = None
|
|
763
|
+
__props__.__dict__["capacity_max_bytes"] = None
|
|
764
|
+
__props__.__dict__["capacity_min_bytes"] = None
|
|
734
765
|
__props__.__dict__["controller_required"] = None
|
|
735
766
|
__props__.__dict__["controllers_expected"] = None
|
|
736
767
|
__props__.__dict__["controllers_healthy"] = None
|
|
@@ -753,6 +784,11 @@ class CsiVolumeRegistration(pulumi.CustomResource):
|
|
|
753
784
|
id: pulumi.Input[str],
|
|
754
785
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
755
786
|
capabilities: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['CsiVolumeRegistrationCapabilityArgs']]]]] = None,
|
|
787
|
+
capacity: Optional[pulumi.Input[int]] = None,
|
|
788
|
+
capacity_max: Optional[pulumi.Input[str]] = None,
|
|
789
|
+
capacity_max_bytes: Optional[pulumi.Input[int]] = None,
|
|
790
|
+
capacity_min: Optional[pulumi.Input[str]] = None,
|
|
791
|
+
capacity_min_bytes: Optional[pulumi.Input[int]] = None,
|
|
756
792
|
context: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
757
793
|
controller_required: Optional[pulumi.Input[bool]] = None,
|
|
758
794
|
controllers_expected: Optional[pulumi.Input[int]] = None,
|
|
@@ -781,6 +817,8 @@ class CsiVolumeRegistration(pulumi.CustomResource):
|
|
|
781
817
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
782
818
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
783
819
|
:param pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['CsiVolumeRegistrationCapabilityArgs']]]] capabilities: `(``Capability``: <required>)` - Options for validating the capability of a volume.
|
|
820
|
+
:param pulumi.Input[str] capacity_max: `(string: <optional>)` - Option to signal a maximum volume size. This may not be supported by all storage providers.
|
|
821
|
+
:param pulumi.Input[str] capacity_min: `(string: <optional>)` - Option to signal a minimum volume size. This may not be supported by all storage providers.
|
|
784
822
|
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] context: `(map[string]string: <optional>)` - An optional key-value map of strings passed directly to the CSI plugin to validate the volume.
|
|
785
823
|
:param pulumi.Input[bool] controller_required: `(boolean)`
|
|
786
824
|
:param pulumi.Input[int] controllers_expected: `(integer)`
|
|
@@ -807,6 +845,11 @@ class CsiVolumeRegistration(pulumi.CustomResource):
|
|
|
807
845
|
__props__ = _CsiVolumeRegistrationState.__new__(_CsiVolumeRegistrationState)
|
|
808
846
|
|
|
809
847
|
__props__.__dict__["capabilities"] = capabilities
|
|
848
|
+
__props__.__dict__["capacity"] = capacity
|
|
849
|
+
__props__.__dict__["capacity_max"] = capacity_max
|
|
850
|
+
__props__.__dict__["capacity_max_bytes"] = capacity_max_bytes
|
|
851
|
+
__props__.__dict__["capacity_min"] = capacity_min
|
|
852
|
+
__props__.__dict__["capacity_min_bytes"] = capacity_min_bytes
|
|
810
853
|
__props__.__dict__["context"] = context
|
|
811
854
|
__props__.__dict__["controller_required"] = controller_required
|
|
812
855
|
__props__.__dict__["controllers_expected"] = controllers_expected
|
|
@@ -837,6 +880,37 @@ class CsiVolumeRegistration(pulumi.CustomResource):
|
|
|
837
880
|
"""
|
|
838
881
|
return pulumi.get(self, "capabilities")
|
|
839
882
|
|
|
883
|
+
@property
|
|
884
|
+
@pulumi.getter
|
|
885
|
+
def capacity(self) -> pulumi.Output[int]:
|
|
886
|
+
return pulumi.get(self, "capacity")
|
|
887
|
+
|
|
888
|
+
@property
|
|
889
|
+
@pulumi.getter(name="capacityMax")
|
|
890
|
+
def capacity_max(self) -> pulumi.Output[Optional[str]]:
|
|
891
|
+
"""
|
|
892
|
+
`(string: <optional>)` - Option to signal a maximum volume size. This may not be supported by all storage providers.
|
|
893
|
+
"""
|
|
894
|
+
return pulumi.get(self, "capacity_max")
|
|
895
|
+
|
|
896
|
+
@property
|
|
897
|
+
@pulumi.getter(name="capacityMaxBytes")
|
|
898
|
+
def capacity_max_bytes(self) -> pulumi.Output[int]:
|
|
899
|
+
return pulumi.get(self, "capacity_max_bytes")
|
|
900
|
+
|
|
901
|
+
@property
|
|
902
|
+
@pulumi.getter(name="capacityMin")
|
|
903
|
+
def capacity_min(self) -> pulumi.Output[Optional[str]]:
|
|
904
|
+
"""
|
|
905
|
+
`(string: <optional>)` - Option to signal a minimum volume size. This may not be supported by all storage providers.
|
|
906
|
+
"""
|
|
907
|
+
return pulumi.get(self, "capacity_min")
|
|
908
|
+
|
|
909
|
+
@property
|
|
910
|
+
@pulumi.getter(name="capacityMinBytes")
|
|
911
|
+
def capacity_min_bytes(self) -> pulumi.Output[int]:
|
|
912
|
+
return pulumi.get(self, "capacity_min_bytes")
|
|
913
|
+
|
|
840
914
|
@property
|
|
841
915
|
@pulumi.getter
|
|
842
916
|
def context(self) -> pulumi.Output[Optional[Mapping[str, str]]]:
|
pulumi_nomad/job.py
CHANGED
|
@@ -27,6 +27,7 @@ class JobArgs:
|
|
|
27
27
|
policy_override: Optional[pulumi.Input[bool]] = None,
|
|
28
28
|
purge_on_destroy: Optional[pulumi.Input[bool]] = None,
|
|
29
29
|
read_allocation_ids: Optional[pulumi.Input[bool]] = None,
|
|
30
|
+
rerun_if_dead: Optional[pulumi.Input[bool]] = None,
|
|
30
31
|
vault_token: Optional[pulumi.Input[str]] = None):
|
|
31
32
|
"""
|
|
32
33
|
The set of arguments for constructing a Job resource.
|
|
@@ -48,6 +49,8 @@ class JobArgs:
|
|
|
48
49
|
soft-mandatory Sentinel policies and register even if they fail.
|
|
49
50
|
:param pulumi.Input[bool] purge_on_destroy: `(boolean: false)` - Set this to true if you want the job to
|
|
50
51
|
be purged when the resource is destroyed.
|
|
52
|
+
:param pulumi.Input[bool] rerun_if_dead: `(boolean: false)` - Set this to true to force the job to run
|
|
53
|
+
again if its status is `dead`.
|
|
51
54
|
:param pulumi.Input[str] vault_token: `(string: <optional>)` - Vault token used when registering this job.
|
|
52
55
|
Will fallback to the value declared in Nomad provider configuration, if any.
|
|
53
56
|
"""
|
|
@@ -75,6 +78,8 @@ class JobArgs:
|
|
|
75
78
|
pulumi.log.warn("""read_allocation_ids is deprecated: Retrieving allocation IDs from the job resource is deprecated and will be removed in a future release. Use the nomad_allocations data source instead.""")
|
|
76
79
|
if read_allocation_ids is not None:
|
|
77
80
|
pulumi.set(__self__, "read_allocation_ids", read_allocation_ids)
|
|
81
|
+
if rerun_if_dead is not None:
|
|
82
|
+
pulumi.set(__self__, "rerun_if_dead", rerun_if_dead)
|
|
78
83
|
if vault_token is not None:
|
|
79
84
|
pulumi.set(__self__, "vault_token", vault_token)
|
|
80
85
|
|
|
@@ -218,6 +223,19 @@ class JobArgs:
|
|
|
218
223
|
def read_allocation_ids(self, value: Optional[pulumi.Input[bool]]):
|
|
219
224
|
pulumi.set(self, "read_allocation_ids", value)
|
|
220
225
|
|
|
226
|
+
@property
|
|
227
|
+
@pulumi.getter(name="rerunIfDead")
|
|
228
|
+
def rerun_if_dead(self) -> Optional[pulumi.Input[bool]]:
|
|
229
|
+
"""
|
|
230
|
+
`(boolean: false)` - Set this to true to force the job to run
|
|
231
|
+
again if its status is `dead`.
|
|
232
|
+
"""
|
|
233
|
+
return pulumi.get(self, "rerun_if_dead")
|
|
234
|
+
|
|
235
|
+
@rerun_if_dead.setter
|
|
236
|
+
def rerun_if_dead(self, value: Optional[pulumi.Input[bool]]):
|
|
237
|
+
pulumi.set(self, "rerun_if_dead", value)
|
|
238
|
+
|
|
221
239
|
@property
|
|
222
240
|
@pulumi.getter(name="vaultToken")
|
|
223
241
|
def vault_token(self) -> Optional[pulumi.Input[str]]:
|
|
@@ -254,6 +272,8 @@ class _JobState:
|
|
|
254
272
|
purge_on_destroy: Optional[pulumi.Input[bool]] = None,
|
|
255
273
|
read_allocation_ids: Optional[pulumi.Input[bool]] = None,
|
|
256
274
|
region: Optional[pulumi.Input[str]] = None,
|
|
275
|
+
rerun_if_dead: Optional[pulumi.Input[bool]] = None,
|
|
276
|
+
status: Optional[pulumi.Input[str]] = None,
|
|
257
277
|
task_groups: Optional[pulumi.Input[Sequence[pulumi.Input['JobTaskGroupArgs']]]] = None,
|
|
258
278
|
type: Optional[pulumi.Input[str]] = None,
|
|
259
279
|
vault_token: Optional[pulumi.Input[str]] = None):
|
|
@@ -285,6 +305,9 @@ class _JobState:
|
|
|
285
305
|
:param pulumi.Input[bool] purge_on_destroy: `(boolean: false)` - Set this to true if you want the job to
|
|
286
306
|
be purged when the resource is destroyed.
|
|
287
307
|
:param pulumi.Input[str] region: The target region for the job, as derived from the jobspec.
|
|
308
|
+
:param pulumi.Input[bool] rerun_if_dead: `(boolean: false)` - Set this to true to force the job to run
|
|
309
|
+
again if its status is `dead`.
|
|
310
|
+
:param pulumi.Input[str] status: The status of the job.
|
|
288
311
|
:param pulumi.Input[str] type: The type of the job, as derived from the jobspec.
|
|
289
312
|
:param pulumi.Input[str] vault_token: `(string: <optional>)` - Vault token used when registering this job.
|
|
290
313
|
Will fallback to the value declared in Nomad provider configuration, if any.
|
|
@@ -333,6 +356,10 @@ class _JobState:
|
|
|
333
356
|
pulumi.set(__self__, "read_allocation_ids", read_allocation_ids)
|
|
334
357
|
if region is not None:
|
|
335
358
|
pulumi.set(__self__, "region", region)
|
|
359
|
+
if rerun_if_dead is not None:
|
|
360
|
+
pulumi.set(__self__, "rerun_if_dead", rerun_if_dead)
|
|
361
|
+
if status is not None:
|
|
362
|
+
pulumi.set(__self__, "status", status)
|
|
336
363
|
if task_groups is not None:
|
|
337
364
|
pulumi.set(__self__, "task_groups", task_groups)
|
|
338
365
|
if type is not None:
|
|
@@ -579,6 +606,31 @@ class _JobState:
|
|
|
579
606
|
def region(self, value: Optional[pulumi.Input[str]]):
|
|
580
607
|
pulumi.set(self, "region", value)
|
|
581
608
|
|
|
609
|
+
@property
|
|
610
|
+
@pulumi.getter(name="rerunIfDead")
|
|
611
|
+
def rerun_if_dead(self) -> Optional[pulumi.Input[bool]]:
|
|
612
|
+
"""
|
|
613
|
+
`(boolean: false)` - Set this to true to force the job to run
|
|
614
|
+
again if its status is `dead`.
|
|
615
|
+
"""
|
|
616
|
+
return pulumi.get(self, "rerun_if_dead")
|
|
617
|
+
|
|
618
|
+
@rerun_if_dead.setter
|
|
619
|
+
def rerun_if_dead(self, value: Optional[pulumi.Input[bool]]):
|
|
620
|
+
pulumi.set(self, "rerun_if_dead", value)
|
|
621
|
+
|
|
622
|
+
@property
|
|
623
|
+
@pulumi.getter
|
|
624
|
+
def status(self) -> Optional[pulumi.Input[str]]:
|
|
625
|
+
"""
|
|
626
|
+
The status of the job.
|
|
627
|
+
"""
|
|
628
|
+
return pulumi.get(self, "status")
|
|
629
|
+
|
|
630
|
+
@status.setter
|
|
631
|
+
def status(self, value: Optional[pulumi.Input[str]]):
|
|
632
|
+
pulumi.set(self, "status", value)
|
|
633
|
+
|
|
582
634
|
@property
|
|
583
635
|
@pulumi.getter(name="taskGroups")
|
|
584
636
|
def task_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['JobTaskGroupArgs']]]]:
|
|
@@ -630,6 +682,7 @@ class Job(pulumi.CustomResource):
|
|
|
630
682
|
policy_override: Optional[pulumi.Input[bool]] = None,
|
|
631
683
|
purge_on_destroy: Optional[pulumi.Input[bool]] = None,
|
|
632
684
|
read_allocation_ids: Optional[pulumi.Input[bool]] = None,
|
|
685
|
+
rerun_if_dead: Optional[pulumi.Input[bool]] = None,
|
|
633
686
|
vault_token: Optional[pulumi.Input[str]] = None,
|
|
634
687
|
__props__=None):
|
|
635
688
|
"""
|
|
@@ -654,6 +707,8 @@ class Job(pulumi.CustomResource):
|
|
|
654
707
|
soft-mandatory Sentinel policies and register even if they fail.
|
|
655
708
|
:param pulumi.Input[bool] purge_on_destroy: `(boolean: false)` - Set this to true if you want the job to
|
|
656
709
|
be purged when the resource is destroyed.
|
|
710
|
+
:param pulumi.Input[bool] rerun_if_dead: `(boolean: false)` - Set this to true to force the job to run
|
|
711
|
+
again if its status is `dead`.
|
|
657
712
|
:param pulumi.Input[str] vault_token: `(string: <optional>)` - Vault token used when registering this job.
|
|
658
713
|
Will fallback to the value declared in Nomad provider configuration, if any.
|
|
659
714
|
"""
|
|
@@ -691,6 +746,7 @@ class Job(pulumi.CustomResource):
|
|
|
691
746
|
policy_override: Optional[pulumi.Input[bool]] = None,
|
|
692
747
|
purge_on_destroy: Optional[pulumi.Input[bool]] = None,
|
|
693
748
|
read_allocation_ids: Optional[pulumi.Input[bool]] = None,
|
|
749
|
+
rerun_if_dead: Optional[pulumi.Input[bool]] = None,
|
|
694
750
|
vault_token: Optional[pulumi.Input[str]] = None,
|
|
695
751
|
__props__=None):
|
|
696
752
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
@@ -714,6 +770,7 @@ class Job(pulumi.CustomResource):
|
|
|
714
770
|
__props__.__dict__["policy_override"] = policy_override
|
|
715
771
|
__props__.__dict__["purge_on_destroy"] = purge_on_destroy
|
|
716
772
|
__props__.__dict__["read_allocation_ids"] = read_allocation_ids
|
|
773
|
+
__props__.__dict__["rerun_if_dead"] = rerun_if_dead
|
|
717
774
|
__props__.__dict__["vault_token"] = None if vault_token is None else pulumi.Output.secret(vault_token)
|
|
718
775
|
__props__.__dict__["allocation_ids"] = None
|
|
719
776
|
__props__.__dict__["datacenters"] = None
|
|
@@ -723,6 +780,7 @@ class Job(pulumi.CustomResource):
|
|
|
723
780
|
__props__.__dict__["name"] = None
|
|
724
781
|
__props__.__dict__["namespace"] = None
|
|
725
782
|
__props__.__dict__["region"] = None
|
|
783
|
+
__props__.__dict__["status"] = None
|
|
726
784
|
__props__.__dict__["task_groups"] = None
|
|
727
785
|
__props__.__dict__["type"] = None
|
|
728
786
|
secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["consulToken", "vaultToken"])
|
|
@@ -756,6 +814,8 @@ class Job(pulumi.CustomResource):
|
|
|
756
814
|
purge_on_destroy: Optional[pulumi.Input[bool]] = None,
|
|
757
815
|
read_allocation_ids: Optional[pulumi.Input[bool]] = None,
|
|
758
816
|
region: Optional[pulumi.Input[str]] = None,
|
|
817
|
+
rerun_if_dead: Optional[pulumi.Input[bool]] = None,
|
|
818
|
+
status: Optional[pulumi.Input[str]] = None,
|
|
759
819
|
task_groups: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['JobTaskGroupArgs']]]]] = None,
|
|
760
820
|
type: Optional[pulumi.Input[str]] = None,
|
|
761
821
|
vault_token: Optional[pulumi.Input[str]] = None) -> 'Job':
|
|
@@ -792,6 +852,9 @@ class Job(pulumi.CustomResource):
|
|
|
792
852
|
:param pulumi.Input[bool] purge_on_destroy: `(boolean: false)` - Set this to true if you want the job to
|
|
793
853
|
be purged when the resource is destroyed.
|
|
794
854
|
:param pulumi.Input[str] region: The target region for the job, as derived from the jobspec.
|
|
855
|
+
:param pulumi.Input[bool] rerun_if_dead: `(boolean: false)` - Set this to true to force the job to run
|
|
856
|
+
again if its status is `dead`.
|
|
857
|
+
:param pulumi.Input[str] status: The status of the job.
|
|
795
858
|
:param pulumi.Input[str] type: The type of the job, as derived from the jobspec.
|
|
796
859
|
:param pulumi.Input[str] vault_token: `(string: <optional>)` - Vault token used when registering this job.
|
|
797
860
|
Will fallback to the value declared in Nomad provider configuration, if any.
|
|
@@ -819,6 +882,8 @@ class Job(pulumi.CustomResource):
|
|
|
819
882
|
__props__.__dict__["purge_on_destroy"] = purge_on_destroy
|
|
820
883
|
__props__.__dict__["read_allocation_ids"] = read_allocation_ids
|
|
821
884
|
__props__.__dict__["region"] = region
|
|
885
|
+
__props__.__dict__["rerun_if_dead"] = rerun_if_dead
|
|
886
|
+
__props__.__dict__["status"] = status
|
|
822
887
|
__props__.__dict__["task_groups"] = task_groups
|
|
823
888
|
__props__.__dict__["type"] = type
|
|
824
889
|
__props__.__dict__["vault_token"] = vault_token
|
|
@@ -987,6 +1052,23 @@ class Job(pulumi.CustomResource):
|
|
|
987
1052
|
"""
|
|
988
1053
|
return pulumi.get(self, "region")
|
|
989
1054
|
|
|
1055
|
+
@property
|
|
1056
|
+
@pulumi.getter(name="rerunIfDead")
|
|
1057
|
+
def rerun_if_dead(self) -> pulumi.Output[Optional[bool]]:
|
|
1058
|
+
"""
|
|
1059
|
+
`(boolean: false)` - Set this to true to force the job to run
|
|
1060
|
+
again if its status is `dead`.
|
|
1061
|
+
"""
|
|
1062
|
+
return pulumi.get(self, "rerun_if_dead")
|
|
1063
|
+
|
|
1064
|
+
@property
|
|
1065
|
+
@pulumi.getter
|
|
1066
|
+
def status(self) -> pulumi.Output[str]:
|
|
1067
|
+
"""
|
|
1068
|
+
The status of the job.
|
|
1069
|
+
"""
|
|
1070
|
+
return pulumi.get(self, "status")
|
|
1071
|
+
|
|
990
1072
|
@property
|
|
991
1073
|
@pulumi.getter(name="taskGroups")
|
|
992
1074
|
def task_groups(self) -> pulumi.Output[Sequence['outputs.JobTaskGroup']]:
|
|
@@ -1,13 +1,13 @@
|
|
|
1
1
|
pulumi_nomad/__init__.py,sha256=QUArXGICF8dmn0esax2QRn_bSJNVdbfnLlaahZRlmAU,4332
|
|
2
2
|
pulumi_nomad/_inputs.py,sha256=UYkywwjA6YcK47y9OHGQKsaKaF0lMMNHADf5ji0bc5I,69191
|
|
3
3
|
pulumi_nomad/_utilities.py,sha256=nNKRJyG0bkCleVzIGnszB5TSQOVUqAHks2baneWhujg,9249
|
|
4
|
-
pulumi_nomad/acl_auth_method.py,sha256=
|
|
4
|
+
pulumi_nomad/acl_auth_method.py,sha256=Tp3ow4U8qa-kg4g-3Qzu87h_GW2YqNg5tSijMKcm71E,23599
|
|
5
5
|
pulumi_nomad/acl_binding_rule.py,sha256=7YZsOVUoabSUsThSiusJBju9S5kYcQGAclPqqRjj3PY,16396
|
|
6
6
|
pulumi_nomad/acl_policy.py,sha256=t1coaWYlkmx7IZIpG3eza4tq8Z_vzZgbjEgYukO_lvA,13550
|
|
7
7
|
pulumi_nomad/acl_role.py,sha256=AzyAijJ-05LPP71sGis0paEqTI9wjVjj9EnTAN1Ln7A,10526
|
|
8
8
|
pulumi_nomad/acl_token.py,sha256=8bqR29azqPxfIprvaVySFv3tL2cb2YjpYY5IDYGqPe4,28545
|
|
9
|
-
pulumi_nomad/csi_volume.py,sha256=
|
|
10
|
-
pulumi_nomad/csi_volume_registration.py,sha256=
|
|
9
|
+
pulumi_nomad/csi_volume.py,sha256=OvyQzy3HejF2Z_cOLVGDRpj9uUvh92QEL0LcW0QGUeQ,50670
|
|
10
|
+
pulumi_nomad/csi_volume_registration.py,sha256=1DUu-tWqeT4MuyJXPLa2w-JuxofW4wsUj0sOkUOK58I,52616
|
|
11
11
|
pulumi_nomad/external_volume.py,sha256=RkqLWGFJrY_JHPErFM0SO0Vvgk6Val6moXaWEV_gBQQ,52267
|
|
12
12
|
pulumi_nomad/get_acl_policies.py,sha256=w928nDzy5ax8uGknhbFGffWkxwpFp-KZ1W5__P-BGis,3550
|
|
13
13
|
pulumi_nomad/get_acl_policy.py,sha256=H8j5lwZ1_oMGUCXJ6Bivqq7ExVsFYVWKmLdNu6lRWQ4,3800
|
|
@@ -32,7 +32,7 @@ pulumi_nomad/get_scaling_policy.py,sha256=dMBw5Qi17KzFyj1hDjtrh6u4Qqw_khbUysERHW
|
|
|
32
32
|
pulumi_nomad/get_scheduler_policy.py,sha256=NCYMl9s00oLdc8j2EkwxNUtq2s9vYU3rDfmtMwQSLPc,4546
|
|
33
33
|
pulumi_nomad/get_variable.py,sha256=FARInWW4OX1W5IwS3GOatclP_BqVcvKqVN7kVFv2tnE,4113
|
|
34
34
|
pulumi_nomad/get_volumes.py,sha256=bxPF8gchK6FhEJcySOi5cnxg0e0bn7xnTvk-2D36vxI,5420
|
|
35
|
-
pulumi_nomad/job.py,sha256=
|
|
35
|
+
pulumi_nomad/job.py,sha256=YMuoAetXRNpQCt4NF15_aIjKIIj9Do9AoSFphqddxzw,51983
|
|
36
36
|
pulumi_nomad/namespace.py,sha256=dCreO2T1cDQdLQJe976q04D2hqHTbYZrg5mIVkiDuRQ,20349
|
|
37
37
|
pulumi_nomad/node_pool.py,sha256=cc7XCrKVakbhKmQLQTPgqLIzcoAnSVDOv8q6hgpwUeg,13078
|
|
38
38
|
pulumi_nomad/outputs.py,sha256=76vrrvbBiIn7Sb05Ybdxsyi0fxygyaMLufajuEYG1Os,96141
|
|
@@ -48,7 +48,7 @@ pulumi_nomad/config/__init__.py,sha256=cfY0smRZD3fDVc93ZIAxEl_IM2pynmXB52n3Ahzi0
|
|
|
48
48
|
pulumi_nomad/config/__init__.pyi,sha256=xqQrj9Co22MZN1IMoQwefoce6b6zI5nQfuA4L_uqw3Q,1865
|
|
49
49
|
pulumi_nomad/config/outputs.py,sha256=L-VjkbG4Oj_tMe8HpJ-B7rQcitQeAP8Rc8OvnZj3qi8,798
|
|
50
50
|
pulumi_nomad/config/vars.py,sha256=pNNlDdaVJeMKr6TPOOJ4wW-_KPneYFizgpPjUIxa9rU,3432
|
|
51
|
-
pulumi_nomad-2.0.
|
|
52
|
-
pulumi_nomad-2.0.
|
|
53
|
-
pulumi_nomad-2.0.
|
|
54
|
-
pulumi_nomad-2.0.
|
|
51
|
+
pulumi_nomad-2.1.0.dist-info/METADATA,sha256=4cdOSr-DWoNRoboCmp1tz_BNyqEFi-AY6D6jxlnvRz4,4719
|
|
52
|
+
pulumi_nomad-2.1.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
|
|
53
|
+
pulumi_nomad-2.1.0.dist-info/top_level.txt,sha256=1JxoZWssmXqN-8vVDXtedeoWtI703uNWUOzlm8Byv-o,13
|
|
54
|
+
pulumi_nomad-2.1.0.dist-info/RECORD,,
|
|
File without changes
|
|
File without changes
|