pulumi-oci 3.8.0a1758168665__py3-none-any.whl → 3.9.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_oci/__init__.py +24 -0
- pulumi_oci/database/__init__.py +1 -0
- pulumi_oci/database/_inputs.py +550 -0
- pulumi_oci/database/cloud_exadata_infrastructure.py +28 -0
- pulumi_oci/database/cloud_exadata_infrastructure_configure_exascale_management.py +1308 -0
- pulumi_oci/database/cloud_vm_cluster.py +77 -0
- pulumi_oci/database/get_cloud_exadata_infrastructure.py +15 -1
- pulumi_oci/database/get_cloud_vm_cluster.py +29 -1
- pulumi_oci/database/outputs.py +515 -0
- pulumi_oci/datasafe/_inputs.py +180 -0
- pulumi_oci/datasafe/audit_policy_management.py +7 -7
- pulumi_oci/datasafe/audit_trail_management.py +2 -0
- pulumi_oci/datasafe/discovery_jobs_result.py +40 -0
- pulumi_oci/datasafe/get_data_safe_configuration.py +2 -2
- pulumi_oci/datasafe/get_discovery_jobs_result.py +29 -1
- pulumi_oci/datasafe/get_discovery_jobs_results.py +23 -1
- pulumi_oci/datasafe/get_masking_reports.py +20 -1
- pulumi_oci/datasafe/get_security_assessment_finding.py +16 -1
- pulumi_oci/datasafe/get_security_assessment_findings.py +26 -3
- pulumi_oci/datasafe/get_sensitive_data_models_sensitive_column.py +30 -1
- pulumi_oci/datasafe/get_sensitive_data_models_sensitive_columns.py +44 -3
- pulumi_oci/datasafe/outputs.py +400 -2
- pulumi_oci/datasafe/sensitive_data_models_sensitive_column.py +58 -0
- pulumi_oci/jms/__init__.py +16 -0
- pulumi_oci/jms/_inputs.py +2068 -29
- pulumi_oci/jms/fleet.py +56 -0
- pulumi_oci/jms/get_fleet.py +29 -1
- pulumi_oci/jms/get_fleet_containers.py +289 -0
- pulumi_oci/jms/get_fleet_export_setting.py +16 -1
- pulumi_oci/jms/get_fleet_library_applications.py +280 -0
- pulumi_oci/jms/get_fleet_library_managed_instances.py +280 -0
- pulumi_oci/jms/get_fleet_summarize_library_inventory.py +211 -0
- pulumi_oci/jms/get_fleet_uncorrelated_package_applications.py +239 -0
- pulumi_oci/jms/get_fleet_uncorrelated_package_managed_instances.py +242 -0
- pulumi_oci/jms/get_fleet_uncorrelated_packages.py +242 -0
- pulumi_oci/jms/get_java_family.py +15 -1
- pulumi_oci/jms/get_jms_plugin.py +2 -2
- pulumi_oci/jms/get_jms_plugins.py +4 -4
- pulumi_oci/jms/get_task_schedule.py +262 -0
- pulumi_oci/jms/get_task_schedules.py +218 -0
- pulumi_oci/jms/get_utils_analyze_applications_configuration.py +153 -0
- pulumi_oci/jms/get_utils_java_migration_analysi.py +316 -0
- pulumi_oci/jms/get_utils_java_migration_analysis.py +177 -0
- pulumi_oci/jms/get_utils_performance_tuning_analysi.py +274 -0
- pulumi_oci/jms/get_utils_performance_tuning_analysis.py +196 -0
- pulumi_oci/jms/get_utils_subscription_acknowledgment_configuration.py +161 -0
- pulumi_oci/jms/jms_plugin.py +36 -15
- pulumi_oci/jms/outputs.py +8500 -3920
- pulumi_oci/jms/task_schedule.py +658 -0
- pulumi_oci/marketplace/__init__.py +2 -0
- pulumi_oci/marketplace/_inputs.py +49 -0
- pulumi_oci/marketplace/get_marketplace_metadata_public_keys.py +144 -0
- pulumi_oci/marketplace/marketplace_external_attested_metadata.py +298 -0
- pulumi_oci/marketplace/outputs.py +124 -0
- pulumi_oci/pulumi-plugin.json +1 -1
- pulumi_oci/redis/get_redis_cluster.py +29 -1
- pulumi_oci/redis/outputs.py +22 -0
- pulumi_oci/redis/redis_cluster.py +56 -0
- {pulumi_oci-3.8.0a1758168665.dist-info → pulumi_oci-3.9.0.dist-info}/METADATA +1 -1
- {pulumi_oci-3.8.0a1758168665.dist-info → pulumi_oci-3.9.0.dist-info}/RECORD +62 -43
- {pulumi_oci-3.8.0a1758168665.dist-info → pulumi_oci-3.9.0.dist-info}/WHEEL +0 -0
- {pulumi_oci-3.8.0a1758168665.dist-info → pulumi_oci-3.9.0.dist-info}/top_level.txt +0 -0
pulumi_oci/jms/_inputs.py
CHANGED
|
@@ -55,12 +55,48 @@ __all__ = [
|
|
|
55
55
|
'JavaDownloadsJavaLicenseAcceptanceRecordCreatedByArgsDict',
|
|
56
56
|
'JavaDownloadsJavaLicenseAcceptanceRecordLastUpdatedByArgs',
|
|
57
57
|
'JavaDownloadsJavaLicenseAcceptanceRecordLastUpdatedByArgsDict',
|
|
58
|
+
'TaskScheduleTaskDetailsArgs',
|
|
59
|
+
'TaskScheduleTaskDetailsArgsDict',
|
|
60
|
+
'TaskScheduleTaskDetailsAddInstallationSiteTaskRequestArgs',
|
|
61
|
+
'TaskScheduleTaskDetailsAddInstallationSiteTaskRequestArgsDict',
|
|
62
|
+
'TaskScheduleTaskDetailsAddInstallationSiteTaskRequestInstallationSiteArgs',
|
|
63
|
+
'TaskScheduleTaskDetailsAddInstallationSiteTaskRequestInstallationSiteArgsDict',
|
|
64
|
+
'TaskScheduleTaskDetailsCryptoTaskRequestArgs',
|
|
65
|
+
'TaskScheduleTaskDetailsCryptoTaskRequestArgsDict',
|
|
66
|
+
'TaskScheduleTaskDetailsCryptoTaskRequestTargetArgs',
|
|
67
|
+
'TaskScheduleTaskDetailsCryptoTaskRequestTargetArgsDict',
|
|
68
|
+
'TaskScheduleTaskDetailsDeployedApplicationMigrationTaskRequestArgs',
|
|
69
|
+
'TaskScheduleTaskDetailsDeployedApplicationMigrationTaskRequestArgsDict',
|
|
70
|
+
'TaskScheduleTaskDetailsDeployedApplicationMigrationTaskRequestTargetArgs',
|
|
71
|
+
'TaskScheduleTaskDetailsDeployedApplicationMigrationTaskRequestTargetArgsDict',
|
|
72
|
+
'TaskScheduleTaskDetailsJavaMigrationTaskRequestArgs',
|
|
73
|
+
'TaskScheduleTaskDetailsJavaMigrationTaskRequestArgsDict',
|
|
74
|
+
'TaskScheduleTaskDetailsJavaMigrationTaskRequestTargetArgs',
|
|
75
|
+
'TaskScheduleTaskDetailsJavaMigrationTaskRequestTargetArgsDict',
|
|
76
|
+
'TaskScheduleTaskDetailsJfrTaskRequestArgs',
|
|
77
|
+
'TaskScheduleTaskDetailsJfrTaskRequestArgsDict',
|
|
78
|
+
'TaskScheduleTaskDetailsJfrTaskRequestTargetArgs',
|
|
79
|
+
'TaskScheduleTaskDetailsJfrTaskRequestTargetArgsDict',
|
|
80
|
+
'TaskScheduleTaskDetailsPerformanceTuningTaskRequestArgs',
|
|
81
|
+
'TaskScheduleTaskDetailsPerformanceTuningTaskRequestArgsDict',
|
|
82
|
+
'TaskScheduleTaskDetailsPerformanceTuningTaskRequestTargetArgs',
|
|
83
|
+
'TaskScheduleTaskDetailsPerformanceTuningTaskRequestTargetArgsDict',
|
|
84
|
+
'TaskScheduleTaskDetailsRemoveInstallationSiteTaskRequestArgs',
|
|
85
|
+
'TaskScheduleTaskDetailsRemoveInstallationSiteTaskRequestArgsDict',
|
|
86
|
+
'TaskScheduleTaskDetailsRemoveInstallationSiteTaskRequestInstallationSiteArgs',
|
|
87
|
+
'TaskScheduleTaskDetailsRemoveInstallationSiteTaskRequestInstallationSiteArgsDict',
|
|
88
|
+
'TaskScheduleTaskDetailsScanJavaServerTaskRequestArgs',
|
|
89
|
+
'TaskScheduleTaskDetailsScanJavaServerTaskRequestArgsDict',
|
|
90
|
+
'TaskScheduleTaskDetailsScanLibraryTaskRequestArgs',
|
|
91
|
+
'TaskScheduleTaskDetailsScanLibraryTaskRequestArgsDict',
|
|
58
92
|
'GetAgentInstallersFilterArgs',
|
|
59
93
|
'GetAgentInstallersFilterArgsDict',
|
|
60
94
|
'GetAnnouncementsFilterArgs',
|
|
61
95
|
'GetAnnouncementsFilterArgsDict',
|
|
62
96
|
'GetFleetBlocklistsFilterArgs',
|
|
63
97
|
'GetFleetBlocklistsFilterArgsDict',
|
|
98
|
+
'GetFleetContainersFilterArgs',
|
|
99
|
+
'GetFleetContainersFilterArgsDict',
|
|
64
100
|
'GetFleetCryptoAnalysisResultsFilterArgs',
|
|
65
101
|
'GetFleetCryptoAnalysisResultsFilterArgsDict',
|
|
66
102
|
'GetFleetDiagnosesFilterArgs',
|
|
@@ -73,8 +109,18 @@ __all__ = [
|
|
|
73
109
|
'GetFleetErrorsFilterArgsDict',
|
|
74
110
|
'GetFleetJavaMigrationAnalysisResultsFilterArgs',
|
|
75
111
|
'GetFleetJavaMigrationAnalysisResultsFilterArgsDict',
|
|
112
|
+
'GetFleetLibraryApplicationsFilterArgs',
|
|
113
|
+
'GetFleetLibraryApplicationsFilterArgsDict',
|
|
114
|
+
'GetFleetLibraryManagedInstancesFilterArgs',
|
|
115
|
+
'GetFleetLibraryManagedInstancesFilterArgsDict',
|
|
76
116
|
'GetFleetPerformanceTuningAnalysisResultsFilterArgs',
|
|
77
117
|
'GetFleetPerformanceTuningAnalysisResultsFilterArgsDict',
|
|
118
|
+
'GetFleetUncorrelatedPackageApplicationsFilterArgs',
|
|
119
|
+
'GetFleetUncorrelatedPackageApplicationsFilterArgsDict',
|
|
120
|
+
'GetFleetUncorrelatedPackageManagedInstancesFilterArgs',
|
|
121
|
+
'GetFleetUncorrelatedPackageManagedInstancesFilterArgsDict',
|
|
122
|
+
'GetFleetUncorrelatedPackagesFilterArgs',
|
|
123
|
+
'GetFleetUncorrelatedPackagesFilterArgsDict',
|
|
78
124
|
'GetFleetsFilterArgs',
|
|
79
125
|
'GetFleetsFilterArgsDict',
|
|
80
126
|
'GetInstallationSitesFilterArgs',
|
|
@@ -99,6 +145,12 @@ __all__ = [
|
|
|
99
145
|
'GetPluginErrorAnalyticsFilterArgsDict',
|
|
100
146
|
'GetPluginErrorsFilterArgs',
|
|
101
147
|
'GetPluginErrorsFilterArgsDict',
|
|
148
|
+
'GetTaskSchedulesFilterArgs',
|
|
149
|
+
'GetTaskSchedulesFilterArgsDict',
|
|
150
|
+
'GetUtilsJavaMigrationAnalysisFilterArgs',
|
|
151
|
+
'GetUtilsJavaMigrationAnalysisFilterArgsDict',
|
|
152
|
+
'GetUtilsPerformanceTuningAnalysisFilterArgs',
|
|
153
|
+
'GetUtilsPerformanceTuningAnalysisFilterArgsDict',
|
|
102
154
|
]
|
|
103
155
|
|
|
104
156
|
MYPY = False
|
|
@@ -1448,16 +1500,1806 @@ class JavaDownloadsJavaLicenseAcceptanceRecordLastUpdatedByArgs:
|
|
|
1448
1500
|
pulumi.set(self, "id", value)
|
|
1449
1501
|
|
|
1450
1502
|
|
|
1503
|
+
if not MYPY:
|
|
1504
|
+
class TaskScheduleTaskDetailsArgsDict(TypedDict):
|
|
1505
|
+
task_type: pulumi.Input[_builtins.str]
|
|
1506
|
+
"""
|
|
1507
|
+
(Updatable) Type of task.
|
|
1508
|
+
|
|
1509
|
+
|
|
1510
|
+
** IMPORTANT **
|
|
1511
|
+
Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
|
|
1512
|
+
"""
|
|
1513
|
+
add_installation_site_task_request: NotRequired[pulumi.Input['TaskScheduleTaskDetailsAddInstallationSiteTaskRequestArgsDict']]
|
|
1514
|
+
"""
|
|
1515
|
+
(Updatable) The list of Java installation sites to add.
|
|
1516
|
+
"""
|
|
1517
|
+
crypto_task_request: NotRequired[pulumi.Input['TaskScheduleTaskDetailsCryptoTaskRequestArgsDict']]
|
|
1518
|
+
"""
|
|
1519
|
+
(Updatable) Details of the request to start a JFR crypto event analysis. When the targets aren't specified, then all managed instances currently in the fleet are selected.
|
|
1520
|
+
"""
|
|
1521
|
+
deployed_application_migration_task_request: NotRequired[pulumi.Input['TaskScheduleTaskDetailsDeployedApplicationMigrationTaskRequestArgsDict']]
|
|
1522
|
+
"""
|
|
1523
|
+
(Updatable) Details of the request to start a Java migration analyses. The analyses requires the managed instance OCID, deployed application key, source JDK version, and target JDK version of each selected application.
|
|
1524
|
+
"""
|
|
1525
|
+
java_migration_task_request: NotRequired[pulumi.Input['TaskScheduleTaskDetailsJavaMigrationTaskRequestArgsDict']]
|
|
1526
|
+
"""
|
|
1527
|
+
(Updatable) Details of the request to start a Java migration analysis. The analysis requires the managed instance OCID, application installation key, source JDK version, and target JDK version of each selected application.
|
|
1528
|
+
"""
|
|
1529
|
+
jfr_task_request: NotRequired[pulumi.Input['TaskScheduleTaskDetailsJfrTaskRequestArgsDict']]
|
|
1530
|
+
"""
|
|
1531
|
+
(Updatable) Details of the request to start JFR recordings. When the targets aren't specified, then all managed instances currently in the Fleet are selected.
|
|
1532
|
+
"""
|
|
1533
|
+
performance_tuning_task_request: NotRequired[pulumi.Input['TaskScheduleTaskDetailsPerformanceTuningTaskRequestArgsDict']]
|
|
1534
|
+
"""
|
|
1535
|
+
(Updatable) Details of the request to start a JFR performance tuning analysis.
|
|
1536
|
+
"""
|
|
1537
|
+
remove_installation_site_task_request: NotRequired[pulumi.Input['TaskScheduleTaskDetailsRemoveInstallationSiteTaskRequestArgsDict']]
|
|
1538
|
+
"""
|
|
1539
|
+
(Updatable) The list of Java installation sites to remove.
|
|
1540
|
+
"""
|
|
1541
|
+
scan_java_server_task_request: NotRequired[pulumi.Input['TaskScheduleTaskDetailsScanJavaServerTaskRequestArgsDict']]
|
|
1542
|
+
"""
|
|
1543
|
+
(Updatable) The list of managed instances to scan.
|
|
1544
|
+
"""
|
|
1545
|
+
scan_library_task_request: NotRequired[pulumi.Input['TaskScheduleTaskDetailsScanLibraryTaskRequestArgsDict']]
|
|
1546
|
+
"""
|
|
1547
|
+
(Updatable) The list of managed instances to scan.
|
|
1548
|
+
"""
|
|
1549
|
+
elif False:
|
|
1550
|
+
TaskScheduleTaskDetailsArgsDict: TypeAlias = Mapping[str, Any]
|
|
1551
|
+
|
|
1552
|
+
@pulumi.input_type
|
|
1553
|
+
class TaskScheduleTaskDetailsArgs:
|
|
1554
|
+
def __init__(__self__, *,
|
|
1555
|
+
task_type: pulumi.Input[_builtins.str],
|
|
1556
|
+
add_installation_site_task_request: Optional[pulumi.Input['TaskScheduleTaskDetailsAddInstallationSiteTaskRequestArgs']] = None,
|
|
1557
|
+
crypto_task_request: Optional[pulumi.Input['TaskScheduleTaskDetailsCryptoTaskRequestArgs']] = None,
|
|
1558
|
+
deployed_application_migration_task_request: Optional[pulumi.Input['TaskScheduleTaskDetailsDeployedApplicationMigrationTaskRequestArgs']] = None,
|
|
1559
|
+
java_migration_task_request: Optional[pulumi.Input['TaskScheduleTaskDetailsJavaMigrationTaskRequestArgs']] = None,
|
|
1560
|
+
jfr_task_request: Optional[pulumi.Input['TaskScheduleTaskDetailsJfrTaskRequestArgs']] = None,
|
|
1561
|
+
performance_tuning_task_request: Optional[pulumi.Input['TaskScheduleTaskDetailsPerformanceTuningTaskRequestArgs']] = None,
|
|
1562
|
+
remove_installation_site_task_request: Optional[pulumi.Input['TaskScheduleTaskDetailsRemoveInstallationSiteTaskRequestArgs']] = None,
|
|
1563
|
+
scan_java_server_task_request: Optional[pulumi.Input['TaskScheduleTaskDetailsScanJavaServerTaskRequestArgs']] = None,
|
|
1564
|
+
scan_library_task_request: Optional[pulumi.Input['TaskScheduleTaskDetailsScanLibraryTaskRequestArgs']] = None):
|
|
1565
|
+
"""
|
|
1566
|
+
:param pulumi.Input[_builtins.str] task_type: (Updatable) Type of task.
|
|
1567
|
+
|
|
1568
|
+
|
|
1569
|
+
** IMPORTANT **
|
|
1570
|
+
Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
|
|
1571
|
+
:param pulumi.Input['TaskScheduleTaskDetailsAddInstallationSiteTaskRequestArgs'] add_installation_site_task_request: (Updatable) The list of Java installation sites to add.
|
|
1572
|
+
:param pulumi.Input['TaskScheduleTaskDetailsCryptoTaskRequestArgs'] crypto_task_request: (Updatable) Details of the request to start a JFR crypto event analysis. When the targets aren't specified, then all managed instances currently in the fleet are selected.
|
|
1573
|
+
:param pulumi.Input['TaskScheduleTaskDetailsDeployedApplicationMigrationTaskRequestArgs'] deployed_application_migration_task_request: (Updatable) Details of the request to start a Java migration analyses. The analyses requires the managed instance OCID, deployed application key, source JDK version, and target JDK version of each selected application.
|
|
1574
|
+
:param pulumi.Input['TaskScheduleTaskDetailsJavaMigrationTaskRequestArgs'] java_migration_task_request: (Updatable) Details of the request to start a Java migration analysis. The analysis requires the managed instance OCID, application installation key, source JDK version, and target JDK version of each selected application.
|
|
1575
|
+
:param pulumi.Input['TaskScheduleTaskDetailsJfrTaskRequestArgs'] jfr_task_request: (Updatable) Details of the request to start JFR recordings. When the targets aren't specified, then all managed instances currently in the Fleet are selected.
|
|
1576
|
+
:param pulumi.Input['TaskScheduleTaskDetailsPerformanceTuningTaskRequestArgs'] performance_tuning_task_request: (Updatable) Details of the request to start a JFR performance tuning analysis.
|
|
1577
|
+
:param pulumi.Input['TaskScheduleTaskDetailsRemoveInstallationSiteTaskRequestArgs'] remove_installation_site_task_request: (Updatable) The list of Java installation sites to remove.
|
|
1578
|
+
:param pulumi.Input['TaskScheduleTaskDetailsScanJavaServerTaskRequestArgs'] scan_java_server_task_request: (Updatable) The list of managed instances to scan.
|
|
1579
|
+
:param pulumi.Input['TaskScheduleTaskDetailsScanLibraryTaskRequestArgs'] scan_library_task_request: (Updatable) The list of managed instances to scan.
|
|
1580
|
+
"""
|
|
1581
|
+
pulumi.set(__self__, "task_type", task_type)
|
|
1582
|
+
if add_installation_site_task_request is not None:
|
|
1583
|
+
pulumi.set(__self__, "add_installation_site_task_request", add_installation_site_task_request)
|
|
1584
|
+
if crypto_task_request is not None:
|
|
1585
|
+
pulumi.set(__self__, "crypto_task_request", crypto_task_request)
|
|
1586
|
+
if deployed_application_migration_task_request is not None:
|
|
1587
|
+
pulumi.set(__self__, "deployed_application_migration_task_request", deployed_application_migration_task_request)
|
|
1588
|
+
if java_migration_task_request is not None:
|
|
1589
|
+
pulumi.set(__self__, "java_migration_task_request", java_migration_task_request)
|
|
1590
|
+
if jfr_task_request is not None:
|
|
1591
|
+
pulumi.set(__self__, "jfr_task_request", jfr_task_request)
|
|
1592
|
+
if performance_tuning_task_request is not None:
|
|
1593
|
+
pulumi.set(__self__, "performance_tuning_task_request", performance_tuning_task_request)
|
|
1594
|
+
if remove_installation_site_task_request is not None:
|
|
1595
|
+
pulumi.set(__self__, "remove_installation_site_task_request", remove_installation_site_task_request)
|
|
1596
|
+
if scan_java_server_task_request is not None:
|
|
1597
|
+
pulumi.set(__self__, "scan_java_server_task_request", scan_java_server_task_request)
|
|
1598
|
+
if scan_library_task_request is not None:
|
|
1599
|
+
pulumi.set(__self__, "scan_library_task_request", scan_library_task_request)
|
|
1600
|
+
|
|
1601
|
+
@_builtins.property
|
|
1602
|
+
@pulumi.getter(name="taskType")
|
|
1603
|
+
def task_type(self) -> pulumi.Input[_builtins.str]:
|
|
1604
|
+
"""
|
|
1605
|
+
(Updatable) Type of task.
|
|
1606
|
+
|
|
1607
|
+
|
|
1608
|
+
** IMPORTANT **
|
|
1609
|
+
Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
|
|
1610
|
+
"""
|
|
1611
|
+
return pulumi.get(self, "task_type")
|
|
1612
|
+
|
|
1613
|
+
@task_type.setter
|
|
1614
|
+
def task_type(self, value: pulumi.Input[_builtins.str]):
|
|
1615
|
+
pulumi.set(self, "task_type", value)
|
|
1616
|
+
|
|
1617
|
+
@_builtins.property
|
|
1618
|
+
@pulumi.getter(name="addInstallationSiteTaskRequest")
|
|
1619
|
+
def add_installation_site_task_request(self) -> Optional[pulumi.Input['TaskScheduleTaskDetailsAddInstallationSiteTaskRequestArgs']]:
|
|
1620
|
+
"""
|
|
1621
|
+
(Updatable) The list of Java installation sites to add.
|
|
1622
|
+
"""
|
|
1623
|
+
return pulumi.get(self, "add_installation_site_task_request")
|
|
1624
|
+
|
|
1625
|
+
@add_installation_site_task_request.setter
|
|
1626
|
+
def add_installation_site_task_request(self, value: Optional[pulumi.Input['TaskScheduleTaskDetailsAddInstallationSiteTaskRequestArgs']]):
|
|
1627
|
+
pulumi.set(self, "add_installation_site_task_request", value)
|
|
1628
|
+
|
|
1629
|
+
@_builtins.property
|
|
1630
|
+
@pulumi.getter(name="cryptoTaskRequest")
|
|
1631
|
+
def crypto_task_request(self) -> Optional[pulumi.Input['TaskScheduleTaskDetailsCryptoTaskRequestArgs']]:
|
|
1632
|
+
"""
|
|
1633
|
+
(Updatable) Details of the request to start a JFR crypto event analysis. When the targets aren't specified, then all managed instances currently in the fleet are selected.
|
|
1634
|
+
"""
|
|
1635
|
+
return pulumi.get(self, "crypto_task_request")
|
|
1636
|
+
|
|
1637
|
+
@crypto_task_request.setter
|
|
1638
|
+
def crypto_task_request(self, value: Optional[pulumi.Input['TaskScheduleTaskDetailsCryptoTaskRequestArgs']]):
|
|
1639
|
+
pulumi.set(self, "crypto_task_request", value)
|
|
1640
|
+
|
|
1641
|
+
@_builtins.property
|
|
1642
|
+
@pulumi.getter(name="deployedApplicationMigrationTaskRequest")
|
|
1643
|
+
def deployed_application_migration_task_request(self) -> Optional[pulumi.Input['TaskScheduleTaskDetailsDeployedApplicationMigrationTaskRequestArgs']]:
|
|
1644
|
+
"""
|
|
1645
|
+
(Updatable) Details of the request to start a Java migration analyses. The analyses requires the managed instance OCID, deployed application key, source JDK version, and target JDK version of each selected application.
|
|
1646
|
+
"""
|
|
1647
|
+
return pulumi.get(self, "deployed_application_migration_task_request")
|
|
1648
|
+
|
|
1649
|
+
@deployed_application_migration_task_request.setter
|
|
1650
|
+
def deployed_application_migration_task_request(self, value: Optional[pulumi.Input['TaskScheduleTaskDetailsDeployedApplicationMigrationTaskRequestArgs']]):
|
|
1651
|
+
pulumi.set(self, "deployed_application_migration_task_request", value)
|
|
1652
|
+
|
|
1653
|
+
@_builtins.property
|
|
1654
|
+
@pulumi.getter(name="javaMigrationTaskRequest")
|
|
1655
|
+
def java_migration_task_request(self) -> Optional[pulumi.Input['TaskScheduleTaskDetailsJavaMigrationTaskRequestArgs']]:
|
|
1656
|
+
"""
|
|
1657
|
+
(Updatable) Details of the request to start a Java migration analysis. The analysis requires the managed instance OCID, application installation key, source JDK version, and target JDK version of each selected application.
|
|
1658
|
+
"""
|
|
1659
|
+
return pulumi.get(self, "java_migration_task_request")
|
|
1660
|
+
|
|
1661
|
+
@java_migration_task_request.setter
|
|
1662
|
+
def java_migration_task_request(self, value: Optional[pulumi.Input['TaskScheduleTaskDetailsJavaMigrationTaskRequestArgs']]):
|
|
1663
|
+
pulumi.set(self, "java_migration_task_request", value)
|
|
1664
|
+
|
|
1665
|
+
@_builtins.property
|
|
1666
|
+
@pulumi.getter(name="jfrTaskRequest")
|
|
1667
|
+
def jfr_task_request(self) -> Optional[pulumi.Input['TaskScheduleTaskDetailsJfrTaskRequestArgs']]:
|
|
1668
|
+
"""
|
|
1669
|
+
(Updatable) Details of the request to start JFR recordings. When the targets aren't specified, then all managed instances currently in the Fleet are selected.
|
|
1670
|
+
"""
|
|
1671
|
+
return pulumi.get(self, "jfr_task_request")
|
|
1672
|
+
|
|
1673
|
+
@jfr_task_request.setter
|
|
1674
|
+
def jfr_task_request(self, value: Optional[pulumi.Input['TaskScheduleTaskDetailsJfrTaskRequestArgs']]):
|
|
1675
|
+
pulumi.set(self, "jfr_task_request", value)
|
|
1676
|
+
|
|
1677
|
+
@_builtins.property
|
|
1678
|
+
@pulumi.getter(name="performanceTuningTaskRequest")
|
|
1679
|
+
def performance_tuning_task_request(self) -> Optional[pulumi.Input['TaskScheduleTaskDetailsPerformanceTuningTaskRequestArgs']]:
|
|
1680
|
+
"""
|
|
1681
|
+
(Updatable) Details of the request to start a JFR performance tuning analysis.
|
|
1682
|
+
"""
|
|
1683
|
+
return pulumi.get(self, "performance_tuning_task_request")
|
|
1684
|
+
|
|
1685
|
+
@performance_tuning_task_request.setter
|
|
1686
|
+
def performance_tuning_task_request(self, value: Optional[pulumi.Input['TaskScheduleTaskDetailsPerformanceTuningTaskRequestArgs']]):
|
|
1687
|
+
pulumi.set(self, "performance_tuning_task_request", value)
|
|
1688
|
+
|
|
1689
|
+
@_builtins.property
|
|
1690
|
+
@pulumi.getter(name="removeInstallationSiteTaskRequest")
|
|
1691
|
+
def remove_installation_site_task_request(self) -> Optional[pulumi.Input['TaskScheduleTaskDetailsRemoveInstallationSiteTaskRequestArgs']]:
|
|
1692
|
+
"""
|
|
1693
|
+
(Updatable) The list of Java installation sites to remove.
|
|
1694
|
+
"""
|
|
1695
|
+
return pulumi.get(self, "remove_installation_site_task_request")
|
|
1696
|
+
|
|
1697
|
+
@remove_installation_site_task_request.setter
|
|
1698
|
+
def remove_installation_site_task_request(self, value: Optional[pulumi.Input['TaskScheduleTaskDetailsRemoveInstallationSiteTaskRequestArgs']]):
|
|
1699
|
+
pulumi.set(self, "remove_installation_site_task_request", value)
|
|
1700
|
+
|
|
1701
|
+
@_builtins.property
|
|
1702
|
+
@pulumi.getter(name="scanJavaServerTaskRequest")
|
|
1703
|
+
def scan_java_server_task_request(self) -> Optional[pulumi.Input['TaskScheduleTaskDetailsScanJavaServerTaskRequestArgs']]:
|
|
1704
|
+
"""
|
|
1705
|
+
(Updatable) The list of managed instances to scan.
|
|
1706
|
+
"""
|
|
1707
|
+
return pulumi.get(self, "scan_java_server_task_request")
|
|
1708
|
+
|
|
1709
|
+
@scan_java_server_task_request.setter
|
|
1710
|
+
def scan_java_server_task_request(self, value: Optional[pulumi.Input['TaskScheduleTaskDetailsScanJavaServerTaskRequestArgs']]):
|
|
1711
|
+
pulumi.set(self, "scan_java_server_task_request", value)
|
|
1712
|
+
|
|
1713
|
+
@_builtins.property
|
|
1714
|
+
@pulumi.getter(name="scanLibraryTaskRequest")
|
|
1715
|
+
def scan_library_task_request(self) -> Optional[pulumi.Input['TaskScheduleTaskDetailsScanLibraryTaskRequestArgs']]:
|
|
1716
|
+
"""
|
|
1717
|
+
(Updatable) The list of managed instances to scan.
|
|
1718
|
+
"""
|
|
1719
|
+
return pulumi.get(self, "scan_library_task_request")
|
|
1720
|
+
|
|
1721
|
+
@scan_library_task_request.setter
|
|
1722
|
+
def scan_library_task_request(self, value: Optional[pulumi.Input['TaskScheduleTaskDetailsScanLibraryTaskRequestArgs']]):
|
|
1723
|
+
pulumi.set(self, "scan_library_task_request", value)
|
|
1724
|
+
|
|
1725
|
+
|
|
1726
|
+
if not MYPY:
|
|
1727
|
+
class TaskScheduleTaskDetailsAddInstallationSiteTaskRequestArgsDict(TypedDict):
|
|
1728
|
+
installation_sites: NotRequired[pulumi.Input[Sequence[pulumi.Input['TaskScheduleTaskDetailsAddInstallationSiteTaskRequestInstallationSiteArgsDict']]]]
|
|
1729
|
+
"""
|
|
1730
|
+
(Updatable) The list of installation sites to add.
|
|
1731
|
+
"""
|
|
1732
|
+
post_installation_actions: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
1733
|
+
"""
|
|
1734
|
+
(Updatable) Optional list of post java installation actions
|
|
1735
|
+
"""
|
|
1736
|
+
elif False:
|
|
1737
|
+
TaskScheduleTaskDetailsAddInstallationSiteTaskRequestArgsDict: TypeAlias = Mapping[str, Any]
|
|
1738
|
+
|
|
1739
|
+
@pulumi.input_type
|
|
1740
|
+
class TaskScheduleTaskDetailsAddInstallationSiteTaskRequestArgs:
|
|
1741
|
+
def __init__(__self__, *,
|
|
1742
|
+
installation_sites: Optional[pulumi.Input[Sequence[pulumi.Input['TaskScheduleTaskDetailsAddInstallationSiteTaskRequestInstallationSiteArgs']]]] = None,
|
|
1743
|
+
post_installation_actions: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
|
|
1744
|
+
"""
|
|
1745
|
+
:param pulumi.Input[Sequence[pulumi.Input['TaskScheduleTaskDetailsAddInstallationSiteTaskRequestInstallationSiteArgs']]] installation_sites: (Updatable) The list of installation sites to add.
|
|
1746
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] post_installation_actions: (Updatable) Optional list of post java installation actions
|
|
1747
|
+
"""
|
|
1748
|
+
if installation_sites is not None:
|
|
1749
|
+
pulumi.set(__self__, "installation_sites", installation_sites)
|
|
1750
|
+
if post_installation_actions is not None:
|
|
1751
|
+
pulumi.set(__self__, "post_installation_actions", post_installation_actions)
|
|
1752
|
+
|
|
1753
|
+
@_builtins.property
|
|
1754
|
+
@pulumi.getter(name="installationSites")
|
|
1755
|
+
def installation_sites(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TaskScheduleTaskDetailsAddInstallationSiteTaskRequestInstallationSiteArgs']]]]:
|
|
1756
|
+
"""
|
|
1757
|
+
(Updatable) The list of installation sites to add.
|
|
1758
|
+
"""
|
|
1759
|
+
return pulumi.get(self, "installation_sites")
|
|
1760
|
+
|
|
1761
|
+
@installation_sites.setter
|
|
1762
|
+
def installation_sites(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TaskScheduleTaskDetailsAddInstallationSiteTaskRequestInstallationSiteArgs']]]]):
|
|
1763
|
+
pulumi.set(self, "installation_sites", value)
|
|
1764
|
+
|
|
1765
|
+
@_builtins.property
|
|
1766
|
+
@pulumi.getter(name="postInstallationActions")
|
|
1767
|
+
def post_installation_actions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1768
|
+
"""
|
|
1769
|
+
(Updatable) Optional list of post java installation actions
|
|
1770
|
+
"""
|
|
1771
|
+
return pulumi.get(self, "post_installation_actions")
|
|
1772
|
+
|
|
1773
|
+
@post_installation_actions.setter
|
|
1774
|
+
def post_installation_actions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
1775
|
+
pulumi.set(self, "post_installation_actions", value)
|
|
1776
|
+
|
|
1777
|
+
|
|
1778
|
+
if not MYPY:
|
|
1779
|
+
class TaskScheduleTaskDetailsAddInstallationSiteTaskRequestInstallationSiteArgsDict(TypedDict):
|
|
1780
|
+
artifact_content_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
1781
|
+
"""
|
|
1782
|
+
(Updatable) Artifact content type for the Java version.
|
|
1783
|
+
"""
|
|
1784
|
+
force_install: NotRequired[pulumi.Input[_builtins.bool]]
|
|
1785
|
+
"""
|
|
1786
|
+
(Updatable) Forces the installation request even if a more recent release is already present in the host.
|
|
1787
|
+
"""
|
|
1788
|
+
headless_mode: NotRequired[pulumi.Input[_builtins.bool]]
|
|
1789
|
+
"""
|
|
1790
|
+
(Updatable) Flag to install headless or headful Java installation. Only valid for Oracle Linux in OCI.
|
|
1791
|
+
"""
|
|
1792
|
+
installation_path: NotRequired[pulumi.Input[_builtins.str]]
|
|
1793
|
+
"""
|
|
1794
|
+
(Updatable) Custom path to install new Java installation site.
|
|
1795
|
+
"""
|
|
1796
|
+
managed_instance_id: NotRequired[pulumi.Input[_builtins.str]]
|
|
1797
|
+
"""
|
|
1798
|
+
(Updatable) The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the related managed instance.
|
|
1799
|
+
"""
|
|
1800
|
+
release_version: NotRequired[pulumi.Input[_builtins.str]]
|
|
1801
|
+
"""
|
|
1802
|
+
(Updatable) The release version of the Java Runtime.
|
|
1803
|
+
"""
|
|
1804
|
+
elif False:
|
|
1805
|
+
TaskScheduleTaskDetailsAddInstallationSiteTaskRequestInstallationSiteArgsDict: TypeAlias = Mapping[str, Any]
|
|
1806
|
+
|
|
1807
|
+
@pulumi.input_type
|
|
1808
|
+
class TaskScheduleTaskDetailsAddInstallationSiteTaskRequestInstallationSiteArgs:
|
|
1809
|
+
def __init__(__self__, *,
|
|
1810
|
+
artifact_content_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1811
|
+
force_install: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1812
|
+
headless_mode: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1813
|
+
installation_path: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1814
|
+
managed_instance_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1815
|
+
release_version: Optional[pulumi.Input[_builtins.str]] = None):
|
|
1816
|
+
"""
|
|
1817
|
+
:param pulumi.Input[_builtins.str] artifact_content_type: (Updatable) Artifact content type for the Java version.
|
|
1818
|
+
:param pulumi.Input[_builtins.bool] force_install: (Updatable) Forces the installation request even if a more recent release is already present in the host.
|
|
1819
|
+
:param pulumi.Input[_builtins.bool] headless_mode: (Updatable) Flag to install headless or headful Java installation. Only valid for Oracle Linux in OCI.
|
|
1820
|
+
:param pulumi.Input[_builtins.str] installation_path: (Updatable) Custom path to install new Java installation site.
|
|
1821
|
+
:param pulumi.Input[_builtins.str] managed_instance_id: (Updatable) The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the related managed instance.
|
|
1822
|
+
:param pulumi.Input[_builtins.str] release_version: (Updatable) The release version of the Java Runtime.
|
|
1823
|
+
"""
|
|
1824
|
+
if artifact_content_type is not None:
|
|
1825
|
+
pulumi.set(__self__, "artifact_content_type", artifact_content_type)
|
|
1826
|
+
if force_install is not None:
|
|
1827
|
+
pulumi.set(__self__, "force_install", force_install)
|
|
1828
|
+
if headless_mode is not None:
|
|
1829
|
+
pulumi.set(__self__, "headless_mode", headless_mode)
|
|
1830
|
+
if installation_path is not None:
|
|
1831
|
+
pulumi.set(__self__, "installation_path", installation_path)
|
|
1832
|
+
if managed_instance_id is not None:
|
|
1833
|
+
pulumi.set(__self__, "managed_instance_id", managed_instance_id)
|
|
1834
|
+
if release_version is not None:
|
|
1835
|
+
pulumi.set(__self__, "release_version", release_version)
|
|
1836
|
+
|
|
1837
|
+
@_builtins.property
|
|
1838
|
+
@pulumi.getter(name="artifactContentType")
|
|
1839
|
+
def artifact_content_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1840
|
+
"""
|
|
1841
|
+
(Updatable) Artifact content type for the Java version.
|
|
1842
|
+
"""
|
|
1843
|
+
return pulumi.get(self, "artifact_content_type")
|
|
1844
|
+
|
|
1845
|
+
@artifact_content_type.setter
|
|
1846
|
+
def artifact_content_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1847
|
+
pulumi.set(self, "artifact_content_type", value)
|
|
1848
|
+
|
|
1849
|
+
@_builtins.property
|
|
1850
|
+
@pulumi.getter(name="forceInstall")
|
|
1851
|
+
def force_install(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1852
|
+
"""
|
|
1853
|
+
(Updatable) Forces the installation request even if a more recent release is already present in the host.
|
|
1854
|
+
"""
|
|
1855
|
+
return pulumi.get(self, "force_install")
|
|
1856
|
+
|
|
1857
|
+
@force_install.setter
|
|
1858
|
+
def force_install(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1859
|
+
pulumi.set(self, "force_install", value)
|
|
1860
|
+
|
|
1861
|
+
@_builtins.property
|
|
1862
|
+
@pulumi.getter(name="headlessMode")
|
|
1863
|
+
def headless_mode(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1864
|
+
"""
|
|
1865
|
+
(Updatable) Flag to install headless or headful Java installation. Only valid for Oracle Linux in OCI.
|
|
1866
|
+
"""
|
|
1867
|
+
return pulumi.get(self, "headless_mode")
|
|
1868
|
+
|
|
1869
|
+
@headless_mode.setter
|
|
1870
|
+
def headless_mode(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1871
|
+
pulumi.set(self, "headless_mode", value)
|
|
1872
|
+
|
|
1873
|
+
@_builtins.property
|
|
1874
|
+
@pulumi.getter(name="installationPath")
|
|
1875
|
+
def installation_path(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1876
|
+
"""
|
|
1877
|
+
(Updatable) Custom path to install new Java installation site.
|
|
1878
|
+
"""
|
|
1879
|
+
return pulumi.get(self, "installation_path")
|
|
1880
|
+
|
|
1881
|
+
@installation_path.setter
|
|
1882
|
+
def installation_path(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1883
|
+
pulumi.set(self, "installation_path", value)
|
|
1884
|
+
|
|
1885
|
+
@_builtins.property
|
|
1886
|
+
@pulumi.getter(name="managedInstanceId")
|
|
1887
|
+
def managed_instance_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1888
|
+
"""
|
|
1889
|
+
(Updatable) The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the related managed instance.
|
|
1890
|
+
"""
|
|
1891
|
+
return pulumi.get(self, "managed_instance_id")
|
|
1892
|
+
|
|
1893
|
+
@managed_instance_id.setter
|
|
1894
|
+
def managed_instance_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1895
|
+
pulumi.set(self, "managed_instance_id", value)
|
|
1896
|
+
|
|
1897
|
+
@_builtins.property
|
|
1898
|
+
@pulumi.getter(name="releaseVersion")
|
|
1899
|
+
def release_version(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1900
|
+
"""
|
|
1901
|
+
(Updatable) The release version of the Java Runtime.
|
|
1902
|
+
"""
|
|
1903
|
+
return pulumi.get(self, "release_version")
|
|
1904
|
+
|
|
1905
|
+
@release_version.setter
|
|
1906
|
+
def release_version(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1907
|
+
pulumi.set(self, "release_version", value)
|
|
1908
|
+
|
|
1909
|
+
|
|
1910
|
+
if not MYPY:
|
|
1911
|
+
class TaskScheduleTaskDetailsCryptoTaskRequestArgsDict(TypedDict):
|
|
1912
|
+
recording_duration_in_minutes: NotRequired[pulumi.Input[_builtins.int]]
|
|
1913
|
+
"""
|
|
1914
|
+
(Updatable) Duration of the JFR recording in minutes.
|
|
1915
|
+
"""
|
|
1916
|
+
targets: NotRequired[pulumi.Input[Sequence[pulumi.Input['TaskScheduleTaskDetailsCryptoTaskRequestTargetArgsDict']]]]
|
|
1917
|
+
"""
|
|
1918
|
+
(Updatable) The attachment targets to start JFR.
|
|
1919
|
+
"""
|
|
1920
|
+
waiting_period_in_minutes: NotRequired[pulumi.Input[_builtins.int]]
|
|
1921
|
+
"""
|
|
1922
|
+
(Updatable) Period to looking for JVMs. In addition to attach to running JVMs when given the command, JVM started within the waiting period will also be attached for JFR. The value should be larger than the agent polling interval setting for the fleet to ensure agent can get the instructions. If not specified, the agent polling interval for the fleet is used.
|
|
1923
|
+
"""
|
|
1924
|
+
elif False:
|
|
1925
|
+
TaskScheduleTaskDetailsCryptoTaskRequestArgsDict: TypeAlias = Mapping[str, Any]
|
|
1926
|
+
|
|
1927
|
+
@pulumi.input_type
|
|
1928
|
+
class TaskScheduleTaskDetailsCryptoTaskRequestArgs:
|
|
1929
|
+
def __init__(__self__, *,
|
|
1930
|
+
recording_duration_in_minutes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1931
|
+
targets: Optional[pulumi.Input[Sequence[pulumi.Input['TaskScheduleTaskDetailsCryptoTaskRequestTargetArgs']]]] = None,
|
|
1932
|
+
waiting_period_in_minutes: Optional[pulumi.Input[_builtins.int]] = None):
|
|
1933
|
+
"""
|
|
1934
|
+
:param pulumi.Input[_builtins.int] recording_duration_in_minutes: (Updatable) Duration of the JFR recording in minutes.
|
|
1935
|
+
:param pulumi.Input[Sequence[pulumi.Input['TaskScheduleTaskDetailsCryptoTaskRequestTargetArgs']]] targets: (Updatable) The attachment targets to start JFR.
|
|
1936
|
+
:param pulumi.Input[_builtins.int] waiting_period_in_minutes: (Updatable) Period to looking for JVMs. In addition to attach to running JVMs when given the command, JVM started within the waiting period will also be attached for JFR. The value should be larger than the agent polling interval setting for the fleet to ensure agent can get the instructions. If not specified, the agent polling interval for the fleet is used.
|
|
1937
|
+
"""
|
|
1938
|
+
if recording_duration_in_minutes is not None:
|
|
1939
|
+
pulumi.set(__self__, "recording_duration_in_minutes", recording_duration_in_minutes)
|
|
1940
|
+
if targets is not None:
|
|
1941
|
+
pulumi.set(__self__, "targets", targets)
|
|
1942
|
+
if waiting_period_in_minutes is not None:
|
|
1943
|
+
pulumi.set(__self__, "waiting_period_in_minutes", waiting_period_in_minutes)
|
|
1944
|
+
|
|
1945
|
+
@_builtins.property
|
|
1946
|
+
@pulumi.getter(name="recordingDurationInMinutes")
|
|
1947
|
+
def recording_duration_in_minutes(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1948
|
+
"""
|
|
1949
|
+
(Updatable) Duration of the JFR recording in minutes.
|
|
1950
|
+
"""
|
|
1951
|
+
return pulumi.get(self, "recording_duration_in_minutes")
|
|
1952
|
+
|
|
1953
|
+
@recording_duration_in_minutes.setter
|
|
1954
|
+
def recording_duration_in_minutes(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1955
|
+
pulumi.set(self, "recording_duration_in_minutes", value)
|
|
1956
|
+
|
|
1957
|
+
@_builtins.property
|
|
1958
|
+
@pulumi.getter
|
|
1959
|
+
def targets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TaskScheduleTaskDetailsCryptoTaskRequestTargetArgs']]]]:
|
|
1960
|
+
"""
|
|
1961
|
+
(Updatable) The attachment targets to start JFR.
|
|
1962
|
+
"""
|
|
1963
|
+
return pulumi.get(self, "targets")
|
|
1964
|
+
|
|
1965
|
+
@targets.setter
|
|
1966
|
+
def targets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TaskScheduleTaskDetailsCryptoTaskRequestTargetArgs']]]]):
|
|
1967
|
+
pulumi.set(self, "targets", value)
|
|
1968
|
+
|
|
1969
|
+
@_builtins.property
|
|
1970
|
+
@pulumi.getter(name="waitingPeriodInMinutes")
|
|
1971
|
+
def waiting_period_in_minutes(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1972
|
+
"""
|
|
1973
|
+
(Updatable) Period to looking for JVMs. In addition to attach to running JVMs when given the command, JVM started within the waiting period will also be attached for JFR. The value should be larger than the agent polling interval setting for the fleet to ensure agent can get the instructions. If not specified, the agent polling interval for the fleet is used.
|
|
1974
|
+
"""
|
|
1975
|
+
return pulumi.get(self, "waiting_period_in_minutes")
|
|
1976
|
+
|
|
1977
|
+
@waiting_period_in_minutes.setter
|
|
1978
|
+
def waiting_period_in_minutes(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1979
|
+
pulumi.set(self, "waiting_period_in_minutes", value)
|
|
1980
|
+
|
|
1981
|
+
|
|
1982
|
+
if not MYPY:
|
|
1983
|
+
class TaskScheduleTaskDetailsCryptoTaskRequestTargetArgsDict(TypedDict):
|
|
1984
|
+
application_installation_key: NotRequired[pulumi.Input[_builtins.str]]
|
|
1985
|
+
"""
|
|
1986
|
+
(Updatable) Unique key that identifies the application installation for JFR data collection.
|
|
1987
|
+
"""
|
|
1988
|
+
application_key: NotRequired[pulumi.Input[_builtins.str]]
|
|
1989
|
+
"""
|
|
1990
|
+
(Updatable) Unique key that identifies the application for JFR data collection.
|
|
1991
|
+
"""
|
|
1992
|
+
container_key: NotRequired[pulumi.Input[_builtins.str]]
|
|
1993
|
+
"""
|
|
1994
|
+
(Updatable) Unique key that identifies the container for JFR data collection.
|
|
1995
|
+
"""
|
|
1996
|
+
jre_key: NotRequired[pulumi.Input[_builtins.str]]
|
|
1997
|
+
"""
|
|
1998
|
+
(Updatable) Unique key that identify the JVM for JFR data collection.
|
|
1999
|
+
"""
|
|
2000
|
+
managed_instance_id: NotRequired[pulumi.Input[_builtins.str]]
|
|
2001
|
+
"""
|
|
2002
|
+
(Updatable) OCID of the Managed Instance to collect JFR data.
|
|
2003
|
+
"""
|
|
2004
|
+
elif False:
|
|
2005
|
+
TaskScheduleTaskDetailsCryptoTaskRequestTargetArgsDict: TypeAlias = Mapping[str, Any]
|
|
2006
|
+
|
|
2007
|
+
@pulumi.input_type
|
|
2008
|
+
class TaskScheduleTaskDetailsCryptoTaskRequestTargetArgs:
|
|
2009
|
+
def __init__(__self__, *,
|
|
2010
|
+
application_installation_key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2011
|
+
application_key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2012
|
+
container_key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2013
|
+
jre_key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2014
|
+
managed_instance_id: Optional[pulumi.Input[_builtins.str]] = None):
|
|
2015
|
+
"""
|
|
2016
|
+
:param pulumi.Input[_builtins.str] application_installation_key: (Updatable) Unique key that identifies the application installation for JFR data collection.
|
|
2017
|
+
:param pulumi.Input[_builtins.str] application_key: (Updatable) Unique key that identifies the application for JFR data collection.
|
|
2018
|
+
:param pulumi.Input[_builtins.str] container_key: (Updatable) Unique key that identifies the container for JFR data collection.
|
|
2019
|
+
:param pulumi.Input[_builtins.str] jre_key: (Updatable) Unique key that identify the JVM for JFR data collection.
|
|
2020
|
+
:param pulumi.Input[_builtins.str] managed_instance_id: (Updatable) OCID of the Managed Instance to collect JFR data.
|
|
2021
|
+
"""
|
|
2022
|
+
if application_installation_key is not None:
|
|
2023
|
+
pulumi.set(__self__, "application_installation_key", application_installation_key)
|
|
2024
|
+
if application_key is not None:
|
|
2025
|
+
pulumi.set(__self__, "application_key", application_key)
|
|
2026
|
+
if container_key is not None:
|
|
2027
|
+
pulumi.set(__self__, "container_key", container_key)
|
|
2028
|
+
if jre_key is not None:
|
|
2029
|
+
pulumi.set(__self__, "jre_key", jre_key)
|
|
2030
|
+
if managed_instance_id is not None:
|
|
2031
|
+
pulumi.set(__self__, "managed_instance_id", managed_instance_id)
|
|
2032
|
+
|
|
2033
|
+
@_builtins.property
|
|
2034
|
+
@pulumi.getter(name="applicationInstallationKey")
|
|
2035
|
+
def application_installation_key(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2036
|
+
"""
|
|
2037
|
+
(Updatable) Unique key that identifies the application installation for JFR data collection.
|
|
2038
|
+
"""
|
|
2039
|
+
return pulumi.get(self, "application_installation_key")
|
|
2040
|
+
|
|
2041
|
+
@application_installation_key.setter
|
|
2042
|
+
def application_installation_key(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2043
|
+
pulumi.set(self, "application_installation_key", value)
|
|
2044
|
+
|
|
2045
|
+
@_builtins.property
|
|
2046
|
+
@pulumi.getter(name="applicationKey")
|
|
2047
|
+
def application_key(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2048
|
+
"""
|
|
2049
|
+
(Updatable) Unique key that identifies the application for JFR data collection.
|
|
2050
|
+
"""
|
|
2051
|
+
return pulumi.get(self, "application_key")
|
|
2052
|
+
|
|
2053
|
+
@application_key.setter
|
|
2054
|
+
def application_key(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2055
|
+
pulumi.set(self, "application_key", value)
|
|
2056
|
+
|
|
2057
|
+
@_builtins.property
|
|
2058
|
+
@pulumi.getter(name="containerKey")
|
|
2059
|
+
def container_key(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2060
|
+
"""
|
|
2061
|
+
(Updatable) Unique key that identifies the container for JFR data collection.
|
|
2062
|
+
"""
|
|
2063
|
+
return pulumi.get(self, "container_key")
|
|
2064
|
+
|
|
2065
|
+
@container_key.setter
|
|
2066
|
+
def container_key(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2067
|
+
pulumi.set(self, "container_key", value)
|
|
2068
|
+
|
|
2069
|
+
@_builtins.property
|
|
2070
|
+
@pulumi.getter(name="jreKey")
|
|
2071
|
+
def jre_key(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2072
|
+
"""
|
|
2073
|
+
(Updatable) Unique key that identify the JVM for JFR data collection.
|
|
2074
|
+
"""
|
|
2075
|
+
return pulumi.get(self, "jre_key")
|
|
2076
|
+
|
|
2077
|
+
@jre_key.setter
|
|
2078
|
+
def jre_key(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2079
|
+
pulumi.set(self, "jre_key", value)
|
|
2080
|
+
|
|
2081
|
+
@_builtins.property
|
|
2082
|
+
@pulumi.getter(name="managedInstanceId")
|
|
2083
|
+
def managed_instance_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2084
|
+
"""
|
|
2085
|
+
(Updatable) OCID of the Managed Instance to collect JFR data.
|
|
2086
|
+
"""
|
|
2087
|
+
return pulumi.get(self, "managed_instance_id")
|
|
2088
|
+
|
|
2089
|
+
@managed_instance_id.setter
|
|
2090
|
+
def managed_instance_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2091
|
+
pulumi.set(self, "managed_instance_id", value)
|
|
2092
|
+
|
|
2093
|
+
|
|
2094
|
+
if not MYPY:
|
|
2095
|
+
class TaskScheduleTaskDetailsDeployedApplicationMigrationTaskRequestArgsDict(TypedDict):
|
|
2096
|
+
targets: NotRequired[pulumi.Input[Sequence[pulumi.Input['TaskScheduleTaskDetailsDeployedApplicationMigrationTaskRequestTargetArgsDict']]]]
|
|
2097
|
+
"""
|
|
2098
|
+
(Updatable) An array of migration analyses requests.
|
|
2099
|
+
"""
|
|
2100
|
+
elif False:
|
|
2101
|
+
TaskScheduleTaskDetailsDeployedApplicationMigrationTaskRequestArgsDict: TypeAlias = Mapping[str, Any]
|
|
2102
|
+
|
|
2103
|
+
@pulumi.input_type
|
|
2104
|
+
class TaskScheduleTaskDetailsDeployedApplicationMigrationTaskRequestArgs:
|
|
2105
|
+
def __init__(__self__, *,
|
|
2106
|
+
targets: Optional[pulumi.Input[Sequence[pulumi.Input['TaskScheduleTaskDetailsDeployedApplicationMigrationTaskRequestTargetArgs']]]] = None):
|
|
2107
|
+
"""
|
|
2108
|
+
:param pulumi.Input[Sequence[pulumi.Input['TaskScheduleTaskDetailsDeployedApplicationMigrationTaskRequestTargetArgs']]] targets: (Updatable) An array of migration analyses requests.
|
|
2109
|
+
"""
|
|
2110
|
+
if targets is not None:
|
|
2111
|
+
pulumi.set(__self__, "targets", targets)
|
|
2112
|
+
|
|
2113
|
+
@_builtins.property
|
|
2114
|
+
@pulumi.getter
|
|
2115
|
+
def targets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TaskScheduleTaskDetailsDeployedApplicationMigrationTaskRequestTargetArgs']]]]:
|
|
2116
|
+
"""
|
|
2117
|
+
(Updatable) An array of migration analyses requests.
|
|
2118
|
+
"""
|
|
2119
|
+
return pulumi.get(self, "targets")
|
|
2120
|
+
|
|
2121
|
+
@targets.setter
|
|
2122
|
+
def targets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TaskScheduleTaskDetailsDeployedApplicationMigrationTaskRequestTargetArgs']]]]):
|
|
2123
|
+
pulumi.set(self, "targets", value)
|
|
2124
|
+
|
|
2125
|
+
|
|
2126
|
+
if not MYPY:
|
|
2127
|
+
class TaskScheduleTaskDetailsDeployedApplicationMigrationTaskRequestTargetArgsDict(TypedDict):
|
|
2128
|
+
deployed_application_installation_key: NotRequired[pulumi.Input[_builtins.str]]
|
|
2129
|
+
"""
|
|
2130
|
+
(Updatable) The unique key that identifies the deployed application's installation path that is to be used for the Java migration analyses.
|
|
2131
|
+
"""
|
|
2132
|
+
exclude_package_prefixes: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
2133
|
+
"""
|
|
2134
|
+
(Updatable) Excludes the packages that starts with the prefix from the migration analyses result. Either this or includePackagePrefixes can be specified.
|
|
2135
|
+
"""
|
|
2136
|
+
include_package_prefixes: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
2137
|
+
"""
|
|
2138
|
+
(Updatable) Includes the packages that starts with the prefix from the migration analyses result. Either this or excludePackagePrefixes can be specified.
|
|
2139
|
+
"""
|
|
2140
|
+
managed_instance_id: NotRequired[pulumi.Input[_builtins.str]]
|
|
2141
|
+
"""
|
|
2142
|
+
(Updatable) The OCID of the managed instance that hosts the application for which the Java migration analyses was performed.
|
|
2143
|
+
"""
|
|
2144
|
+
source_jdk_version: NotRequired[pulumi.Input[_builtins.str]]
|
|
2145
|
+
"""
|
|
2146
|
+
(Updatable) The JDK version the application is currently running on.
|
|
2147
|
+
"""
|
|
2148
|
+
target_jdk_version: NotRequired[pulumi.Input[_builtins.str]]
|
|
2149
|
+
"""
|
|
2150
|
+
(Updatable) The JDK version against which the migration analyses was performed to identify effort required to move from source JDK.
|
|
2151
|
+
"""
|
|
2152
|
+
elif False:
|
|
2153
|
+
TaskScheduleTaskDetailsDeployedApplicationMigrationTaskRequestTargetArgsDict: TypeAlias = Mapping[str, Any]
|
|
2154
|
+
|
|
2155
|
+
@pulumi.input_type
|
|
2156
|
+
class TaskScheduleTaskDetailsDeployedApplicationMigrationTaskRequestTargetArgs:
|
|
2157
|
+
def __init__(__self__, *,
|
|
2158
|
+
deployed_application_installation_key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2159
|
+
exclude_package_prefixes: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
2160
|
+
include_package_prefixes: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
2161
|
+
managed_instance_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2162
|
+
source_jdk_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2163
|
+
target_jdk_version: Optional[pulumi.Input[_builtins.str]] = None):
|
|
2164
|
+
"""
|
|
2165
|
+
:param pulumi.Input[_builtins.str] deployed_application_installation_key: (Updatable) The unique key that identifies the deployed application's installation path that is to be used for the Java migration analyses.
|
|
2166
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] exclude_package_prefixes: (Updatable) Excludes the packages that starts with the prefix from the migration analyses result. Either this or includePackagePrefixes can be specified.
|
|
2167
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] include_package_prefixes: (Updatable) Includes the packages that starts with the prefix from the migration analyses result. Either this or excludePackagePrefixes can be specified.
|
|
2168
|
+
:param pulumi.Input[_builtins.str] managed_instance_id: (Updatable) The OCID of the managed instance that hosts the application for which the Java migration analyses was performed.
|
|
2169
|
+
:param pulumi.Input[_builtins.str] source_jdk_version: (Updatable) The JDK version the application is currently running on.
|
|
2170
|
+
:param pulumi.Input[_builtins.str] target_jdk_version: (Updatable) The JDK version against which the migration analyses was performed to identify effort required to move from source JDK.
|
|
2171
|
+
"""
|
|
2172
|
+
if deployed_application_installation_key is not None:
|
|
2173
|
+
pulumi.set(__self__, "deployed_application_installation_key", deployed_application_installation_key)
|
|
2174
|
+
if exclude_package_prefixes is not None:
|
|
2175
|
+
pulumi.set(__self__, "exclude_package_prefixes", exclude_package_prefixes)
|
|
2176
|
+
if include_package_prefixes is not None:
|
|
2177
|
+
pulumi.set(__self__, "include_package_prefixes", include_package_prefixes)
|
|
2178
|
+
if managed_instance_id is not None:
|
|
2179
|
+
pulumi.set(__self__, "managed_instance_id", managed_instance_id)
|
|
2180
|
+
if source_jdk_version is not None:
|
|
2181
|
+
pulumi.set(__self__, "source_jdk_version", source_jdk_version)
|
|
2182
|
+
if target_jdk_version is not None:
|
|
2183
|
+
pulumi.set(__self__, "target_jdk_version", target_jdk_version)
|
|
2184
|
+
|
|
2185
|
+
@_builtins.property
|
|
2186
|
+
@pulumi.getter(name="deployedApplicationInstallationKey")
|
|
2187
|
+
def deployed_application_installation_key(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2188
|
+
"""
|
|
2189
|
+
(Updatable) The unique key that identifies the deployed application's installation path that is to be used for the Java migration analyses.
|
|
2190
|
+
"""
|
|
2191
|
+
return pulumi.get(self, "deployed_application_installation_key")
|
|
2192
|
+
|
|
2193
|
+
@deployed_application_installation_key.setter
|
|
2194
|
+
def deployed_application_installation_key(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2195
|
+
pulumi.set(self, "deployed_application_installation_key", value)
|
|
2196
|
+
|
|
2197
|
+
@_builtins.property
|
|
2198
|
+
@pulumi.getter(name="excludePackagePrefixes")
|
|
2199
|
+
def exclude_package_prefixes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
2200
|
+
"""
|
|
2201
|
+
(Updatable) Excludes the packages that starts with the prefix from the migration analyses result. Either this or includePackagePrefixes can be specified.
|
|
2202
|
+
"""
|
|
2203
|
+
return pulumi.get(self, "exclude_package_prefixes")
|
|
2204
|
+
|
|
2205
|
+
@exclude_package_prefixes.setter
|
|
2206
|
+
def exclude_package_prefixes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
2207
|
+
pulumi.set(self, "exclude_package_prefixes", value)
|
|
2208
|
+
|
|
2209
|
+
@_builtins.property
|
|
2210
|
+
@pulumi.getter(name="includePackagePrefixes")
|
|
2211
|
+
def include_package_prefixes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
2212
|
+
"""
|
|
2213
|
+
(Updatable) Includes the packages that starts with the prefix from the migration analyses result. Either this or excludePackagePrefixes can be specified.
|
|
2214
|
+
"""
|
|
2215
|
+
return pulumi.get(self, "include_package_prefixes")
|
|
2216
|
+
|
|
2217
|
+
@include_package_prefixes.setter
|
|
2218
|
+
def include_package_prefixes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
2219
|
+
pulumi.set(self, "include_package_prefixes", value)
|
|
2220
|
+
|
|
2221
|
+
@_builtins.property
|
|
2222
|
+
@pulumi.getter(name="managedInstanceId")
|
|
2223
|
+
def managed_instance_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2224
|
+
"""
|
|
2225
|
+
(Updatable) The OCID of the managed instance that hosts the application for which the Java migration analyses was performed.
|
|
2226
|
+
"""
|
|
2227
|
+
return pulumi.get(self, "managed_instance_id")
|
|
2228
|
+
|
|
2229
|
+
@managed_instance_id.setter
|
|
2230
|
+
def managed_instance_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2231
|
+
pulumi.set(self, "managed_instance_id", value)
|
|
2232
|
+
|
|
2233
|
+
@_builtins.property
|
|
2234
|
+
@pulumi.getter(name="sourceJdkVersion")
|
|
2235
|
+
def source_jdk_version(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2236
|
+
"""
|
|
2237
|
+
(Updatable) The JDK version the application is currently running on.
|
|
2238
|
+
"""
|
|
2239
|
+
return pulumi.get(self, "source_jdk_version")
|
|
2240
|
+
|
|
2241
|
+
@source_jdk_version.setter
|
|
2242
|
+
def source_jdk_version(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2243
|
+
pulumi.set(self, "source_jdk_version", value)
|
|
2244
|
+
|
|
2245
|
+
@_builtins.property
|
|
2246
|
+
@pulumi.getter(name="targetJdkVersion")
|
|
2247
|
+
def target_jdk_version(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2248
|
+
"""
|
|
2249
|
+
(Updatable) The JDK version against which the migration analyses was performed to identify effort required to move from source JDK.
|
|
2250
|
+
"""
|
|
2251
|
+
return pulumi.get(self, "target_jdk_version")
|
|
2252
|
+
|
|
2253
|
+
@target_jdk_version.setter
|
|
2254
|
+
def target_jdk_version(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2255
|
+
pulumi.set(self, "target_jdk_version", value)
|
|
2256
|
+
|
|
2257
|
+
|
|
2258
|
+
if not MYPY:
|
|
2259
|
+
class TaskScheduleTaskDetailsJavaMigrationTaskRequestArgsDict(TypedDict):
|
|
2260
|
+
targets: NotRequired[pulumi.Input[Sequence[pulumi.Input['TaskScheduleTaskDetailsJavaMigrationTaskRequestTargetArgsDict']]]]
|
|
2261
|
+
"""
|
|
2262
|
+
(Updatable) An array of migration analysis requests.
|
|
2263
|
+
"""
|
|
2264
|
+
elif False:
|
|
2265
|
+
TaskScheduleTaskDetailsJavaMigrationTaskRequestArgsDict: TypeAlias = Mapping[str, Any]
|
|
2266
|
+
|
|
2267
|
+
@pulumi.input_type
|
|
2268
|
+
class TaskScheduleTaskDetailsJavaMigrationTaskRequestArgs:
|
|
2269
|
+
def __init__(__self__, *,
|
|
2270
|
+
targets: Optional[pulumi.Input[Sequence[pulumi.Input['TaskScheduleTaskDetailsJavaMigrationTaskRequestTargetArgs']]]] = None):
|
|
2271
|
+
"""
|
|
2272
|
+
:param pulumi.Input[Sequence[pulumi.Input['TaskScheduleTaskDetailsJavaMigrationTaskRequestTargetArgs']]] targets: (Updatable) An array of migration analysis requests.
|
|
2273
|
+
"""
|
|
2274
|
+
if targets is not None:
|
|
2275
|
+
pulumi.set(__self__, "targets", targets)
|
|
2276
|
+
|
|
2277
|
+
@_builtins.property
|
|
2278
|
+
@pulumi.getter
|
|
2279
|
+
def targets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TaskScheduleTaskDetailsJavaMigrationTaskRequestTargetArgs']]]]:
|
|
2280
|
+
"""
|
|
2281
|
+
(Updatable) An array of migration analysis requests.
|
|
2282
|
+
"""
|
|
2283
|
+
return pulumi.get(self, "targets")
|
|
2284
|
+
|
|
2285
|
+
@targets.setter
|
|
2286
|
+
def targets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TaskScheduleTaskDetailsJavaMigrationTaskRequestTargetArgs']]]]):
|
|
2287
|
+
pulumi.set(self, "targets", value)
|
|
2288
|
+
|
|
2289
|
+
|
|
2290
|
+
if not MYPY:
|
|
2291
|
+
class TaskScheduleTaskDetailsJavaMigrationTaskRequestTargetArgsDict(TypedDict):
|
|
2292
|
+
application_installation_key: NotRequired[pulumi.Input[_builtins.str]]
|
|
2293
|
+
"""
|
|
2294
|
+
(Updatable) The unique key that identifies the application's installation path that is to be used for the Java migration analysis.
|
|
2295
|
+
"""
|
|
2296
|
+
exclude_package_prefixes: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
2297
|
+
"""
|
|
2298
|
+
(Updatable) Excludes the packages that starts with the prefix from the migration analysis result. Either this or includePackagePrefixes can be specified.
|
|
2299
|
+
"""
|
|
2300
|
+
include_package_prefixes: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
2301
|
+
"""
|
|
2302
|
+
(Updatable) includes the packages that starts with the prefix from the migration analysis result. Either this or excludePackagePrefixes can be specified.
|
|
2303
|
+
"""
|
|
2304
|
+
managed_instance_id: NotRequired[pulumi.Input[_builtins.str]]
|
|
2305
|
+
"""
|
|
2306
|
+
(Updatable) The OCID of the managed instance that hosts the application for which the Java migration analysis was performed.
|
|
2307
|
+
"""
|
|
2308
|
+
source_jdk_version: NotRequired[pulumi.Input[_builtins.str]]
|
|
2309
|
+
"""
|
|
2310
|
+
(Updatable) The JDK version the application is currently running on.
|
|
2311
|
+
"""
|
|
2312
|
+
target_jdk_version: NotRequired[pulumi.Input[_builtins.str]]
|
|
2313
|
+
"""
|
|
2314
|
+
(Updatable) The JDK version against which the migration analysis was performed to identify effort required to move from source JDK.
|
|
2315
|
+
"""
|
|
2316
|
+
elif False:
|
|
2317
|
+
TaskScheduleTaskDetailsJavaMigrationTaskRequestTargetArgsDict: TypeAlias = Mapping[str, Any]
|
|
2318
|
+
|
|
2319
|
+
@pulumi.input_type
|
|
2320
|
+
class TaskScheduleTaskDetailsJavaMigrationTaskRequestTargetArgs:
|
|
2321
|
+
def __init__(__self__, *,
|
|
2322
|
+
application_installation_key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2323
|
+
exclude_package_prefixes: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
2324
|
+
include_package_prefixes: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
2325
|
+
managed_instance_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2326
|
+
source_jdk_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2327
|
+
target_jdk_version: Optional[pulumi.Input[_builtins.str]] = None):
|
|
2328
|
+
"""
|
|
2329
|
+
:param pulumi.Input[_builtins.str] application_installation_key: (Updatable) The unique key that identifies the application's installation path that is to be used for the Java migration analysis.
|
|
2330
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] exclude_package_prefixes: (Updatable) Excludes the packages that starts with the prefix from the migration analysis result. Either this or includePackagePrefixes can be specified.
|
|
2331
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] include_package_prefixes: (Updatable) includes the packages that starts with the prefix from the migration analysis result. Either this or excludePackagePrefixes can be specified.
|
|
2332
|
+
:param pulumi.Input[_builtins.str] managed_instance_id: (Updatable) The OCID of the managed instance that hosts the application for which the Java migration analysis was performed.
|
|
2333
|
+
:param pulumi.Input[_builtins.str] source_jdk_version: (Updatable) The JDK version the application is currently running on.
|
|
2334
|
+
:param pulumi.Input[_builtins.str] target_jdk_version: (Updatable) The JDK version against which the migration analysis was performed to identify effort required to move from source JDK.
|
|
2335
|
+
"""
|
|
2336
|
+
if application_installation_key is not None:
|
|
2337
|
+
pulumi.set(__self__, "application_installation_key", application_installation_key)
|
|
2338
|
+
if exclude_package_prefixes is not None:
|
|
2339
|
+
pulumi.set(__self__, "exclude_package_prefixes", exclude_package_prefixes)
|
|
2340
|
+
if include_package_prefixes is not None:
|
|
2341
|
+
pulumi.set(__self__, "include_package_prefixes", include_package_prefixes)
|
|
2342
|
+
if managed_instance_id is not None:
|
|
2343
|
+
pulumi.set(__self__, "managed_instance_id", managed_instance_id)
|
|
2344
|
+
if source_jdk_version is not None:
|
|
2345
|
+
pulumi.set(__self__, "source_jdk_version", source_jdk_version)
|
|
2346
|
+
if target_jdk_version is not None:
|
|
2347
|
+
pulumi.set(__self__, "target_jdk_version", target_jdk_version)
|
|
2348
|
+
|
|
2349
|
+
@_builtins.property
|
|
2350
|
+
@pulumi.getter(name="applicationInstallationKey")
|
|
2351
|
+
def application_installation_key(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2352
|
+
"""
|
|
2353
|
+
(Updatable) The unique key that identifies the application's installation path that is to be used for the Java migration analysis.
|
|
2354
|
+
"""
|
|
2355
|
+
return pulumi.get(self, "application_installation_key")
|
|
2356
|
+
|
|
2357
|
+
@application_installation_key.setter
|
|
2358
|
+
def application_installation_key(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2359
|
+
pulumi.set(self, "application_installation_key", value)
|
|
2360
|
+
|
|
2361
|
+
@_builtins.property
|
|
2362
|
+
@pulumi.getter(name="excludePackagePrefixes")
|
|
2363
|
+
def exclude_package_prefixes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
2364
|
+
"""
|
|
2365
|
+
(Updatable) Excludes the packages that starts with the prefix from the migration analysis result. Either this or includePackagePrefixes can be specified.
|
|
2366
|
+
"""
|
|
2367
|
+
return pulumi.get(self, "exclude_package_prefixes")
|
|
2368
|
+
|
|
2369
|
+
@exclude_package_prefixes.setter
|
|
2370
|
+
def exclude_package_prefixes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
2371
|
+
pulumi.set(self, "exclude_package_prefixes", value)
|
|
2372
|
+
|
|
2373
|
+
@_builtins.property
|
|
2374
|
+
@pulumi.getter(name="includePackagePrefixes")
|
|
2375
|
+
def include_package_prefixes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
2376
|
+
"""
|
|
2377
|
+
(Updatable) includes the packages that starts with the prefix from the migration analysis result. Either this or excludePackagePrefixes can be specified.
|
|
2378
|
+
"""
|
|
2379
|
+
return pulumi.get(self, "include_package_prefixes")
|
|
2380
|
+
|
|
2381
|
+
@include_package_prefixes.setter
|
|
2382
|
+
def include_package_prefixes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
2383
|
+
pulumi.set(self, "include_package_prefixes", value)
|
|
2384
|
+
|
|
2385
|
+
@_builtins.property
|
|
2386
|
+
@pulumi.getter(name="managedInstanceId")
|
|
2387
|
+
def managed_instance_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2388
|
+
"""
|
|
2389
|
+
(Updatable) The OCID of the managed instance that hosts the application for which the Java migration analysis was performed.
|
|
2390
|
+
"""
|
|
2391
|
+
return pulumi.get(self, "managed_instance_id")
|
|
2392
|
+
|
|
2393
|
+
@managed_instance_id.setter
|
|
2394
|
+
def managed_instance_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2395
|
+
pulumi.set(self, "managed_instance_id", value)
|
|
2396
|
+
|
|
2397
|
+
@_builtins.property
|
|
2398
|
+
@pulumi.getter(name="sourceJdkVersion")
|
|
2399
|
+
def source_jdk_version(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2400
|
+
"""
|
|
2401
|
+
(Updatable) The JDK version the application is currently running on.
|
|
2402
|
+
"""
|
|
2403
|
+
return pulumi.get(self, "source_jdk_version")
|
|
2404
|
+
|
|
2405
|
+
@source_jdk_version.setter
|
|
2406
|
+
def source_jdk_version(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2407
|
+
pulumi.set(self, "source_jdk_version", value)
|
|
2408
|
+
|
|
2409
|
+
@_builtins.property
|
|
2410
|
+
@pulumi.getter(name="targetJdkVersion")
|
|
2411
|
+
def target_jdk_version(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2412
|
+
"""
|
|
2413
|
+
(Updatable) The JDK version against which the migration analysis was performed to identify effort required to move from source JDK.
|
|
2414
|
+
"""
|
|
2415
|
+
return pulumi.get(self, "target_jdk_version")
|
|
2416
|
+
|
|
2417
|
+
@target_jdk_version.setter
|
|
2418
|
+
def target_jdk_version(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2419
|
+
pulumi.set(self, "target_jdk_version", value)
|
|
2420
|
+
|
|
2421
|
+
|
|
2422
|
+
if not MYPY:
|
|
2423
|
+
class TaskScheduleTaskDetailsJfrTaskRequestArgsDict(TypedDict):
|
|
2424
|
+
jfc_profile_name: NotRequired[pulumi.Input[_builtins.str]]
|
|
2425
|
+
"""
|
|
2426
|
+
(Updatable) The profile used for JFR events selection. If the name isn't recognized, the settings from jfcV1 or jfcV2 will be used depending on the JVM version. Both jfcV2 and jfcV1 should be provided to ensure JFR collection on different JVM versions.
|
|
2427
|
+
"""
|
|
2428
|
+
jfc_v1: NotRequired[pulumi.Input[_builtins.str]]
|
|
2429
|
+
"""
|
|
2430
|
+
(Updatable) The BASE64 encoded string of JFR settings XML with schema used by JDK 8.
|
|
2431
|
+
"""
|
|
2432
|
+
jfc_v2: NotRequired[pulumi.Input[_builtins.str]]
|
|
2433
|
+
"""
|
|
2434
|
+
(Updatable) The BASE64 encoded string of JFR settings XML with [schema used by JDK 9 and after](https://raw.githubusercontent.com/openjdk/jdk/master/src/jdk.jfr/share/classes/jdk/jfr/internal/jfc/jfc.xsd).
|
|
2435
|
+
"""
|
|
2436
|
+
recording_duration_in_minutes: NotRequired[pulumi.Input[_builtins.int]]
|
|
2437
|
+
"""
|
|
2438
|
+
(Updatable) Duration of the JFR recording in minutes.
|
|
2439
|
+
"""
|
|
2440
|
+
recording_size_in_mb: NotRequired[pulumi.Input[_builtins.int]]
|
|
2441
|
+
"""
|
|
2442
|
+
(Updatable) The maximum size limit for the JFR file collected.
|
|
2443
|
+
"""
|
|
2444
|
+
targets: NotRequired[pulumi.Input[Sequence[pulumi.Input['TaskScheduleTaskDetailsJfrTaskRequestTargetArgsDict']]]]
|
|
2445
|
+
"""
|
|
2446
|
+
(Updatable) The attachment targets to start JFR.
|
|
2447
|
+
"""
|
|
2448
|
+
waiting_period_in_minutes: NotRequired[pulumi.Input[_builtins.int]]
|
|
2449
|
+
"""
|
|
2450
|
+
(Updatable) Period to looking for JVMs. In addition to attach to running JVMs when given the command, JVM started within the waiting period will also be attached for JFR. The value should be larger than the agent polling interval setting for the fleet to ensure agent can get the instructions. If not specified, the agent polling interval for the fleet is used.
|
|
2451
|
+
"""
|
|
2452
|
+
elif False:
|
|
2453
|
+
TaskScheduleTaskDetailsJfrTaskRequestArgsDict: TypeAlias = Mapping[str, Any]
|
|
2454
|
+
|
|
2455
|
+
@pulumi.input_type
|
|
2456
|
+
class TaskScheduleTaskDetailsJfrTaskRequestArgs:
|
|
2457
|
+
def __init__(__self__, *,
|
|
2458
|
+
jfc_profile_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2459
|
+
jfc_v1: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2460
|
+
jfc_v2: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2461
|
+
recording_duration_in_minutes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2462
|
+
recording_size_in_mb: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2463
|
+
targets: Optional[pulumi.Input[Sequence[pulumi.Input['TaskScheduleTaskDetailsJfrTaskRequestTargetArgs']]]] = None,
|
|
2464
|
+
waiting_period_in_minutes: Optional[pulumi.Input[_builtins.int]] = None):
|
|
2465
|
+
"""
|
|
2466
|
+
:param pulumi.Input[_builtins.str] jfc_profile_name: (Updatable) The profile used for JFR events selection. If the name isn't recognized, the settings from jfcV1 or jfcV2 will be used depending on the JVM version. Both jfcV2 and jfcV1 should be provided to ensure JFR collection on different JVM versions.
|
|
2467
|
+
:param pulumi.Input[_builtins.str] jfc_v1: (Updatable) The BASE64 encoded string of JFR settings XML with schema used by JDK 8.
|
|
2468
|
+
:param pulumi.Input[_builtins.str] jfc_v2: (Updatable) The BASE64 encoded string of JFR settings XML with [schema used by JDK 9 and after](https://raw.githubusercontent.com/openjdk/jdk/master/src/jdk.jfr/share/classes/jdk/jfr/internal/jfc/jfc.xsd).
|
|
2469
|
+
:param pulumi.Input[_builtins.int] recording_duration_in_minutes: (Updatable) Duration of the JFR recording in minutes.
|
|
2470
|
+
:param pulumi.Input[_builtins.int] recording_size_in_mb: (Updatable) The maximum size limit for the JFR file collected.
|
|
2471
|
+
:param pulumi.Input[Sequence[pulumi.Input['TaskScheduleTaskDetailsJfrTaskRequestTargetArgs']]] targets: (Updatable) The attachment targets to start JFR.
|
|
2472
|
+
:param pulumi.Input[_builtins.int] waiting_period_in_minutes: (Updatable) Period to looking for JVMs. In addition to attach to running JVMs when given the command, JVM started within the waiting period will also be attached for JFR. The value should be larger than the agent polling interval setting for the fleet to ensure agent can get the instructions. If not specified, the agent polling interval for the fleet is used.
|
|
2473
|
+
"""
|
|
2474
|
+
if jfc_profile_name is not None:
|
|
2475
|
+
pulumi.set(__self__, "jfc_profile_name", jfc_profile_name)
|
|
2476
|
+
if jfc_v1 is not None:
|
|
2477
|
+
pulumi.set(__self__, "jfc_v1", jfc_v1)
|
|
2478
|
+
if jfc_v2 is not None:
|
|
2479
|
+
pulumi.set(__self__, "jfc_v2", jfc_v2)
|
|
2480
|
+
if recording_duration_in_minutes is not None:
|
|
2481
|
+
pulumi.set(__self__, "recording_duration_in_minutes", recording_duration_in_minutes)
|
|
2482
|
+
if recording_size_in_mb is not None:
|
|
2483
|
+
pulumi.set(__self__, "recording_size_in_mb", recording_size_in_mb)
|
|
2484
|
+
if targets is not None:
|
|
2485
|
+
pulumi.set(__self__, "targets", targets)
|
|
2486
|
+
if waiting_period_in_minutes is not None:
|
|
2487
|
+
pulumi.set(__self__, "waiting_period_in_minutes", waiting_period_in_minutes)
|
|
2488
|
+
|
|
2489
|
+
@_builtins.property
|
|
2490
|
+
@pulumi.getter(name="jfcProfileName")
|
|
2491
|
+
def jfc_profile_name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2492
|
+
"""
|
|
2493
|
+
(Updatable) The profile used for JFR events selection. If the name isn't recognized, the settings from jfcV1 or jfcV2 will be used depending on the JVM version. Both jfcV2 and jfcV1 should be provided to ensure JFR collection on different JVM versions.
|
|
2494
|
+
"""
|
|
2495
|
+
return pulumi.get(self, "jfc_profile_name")
|
|
2496
|
+
|
|
2497
|
+
@jfc_profile_name.setter
|
|
2498
|
+
def jfc_profile_name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2499
|
+
pulumi.set(self, "jfc_profile_name", value)
|
|
2500
|
+
|
|
2501
|
+
@_builtins.property
|
|
2502
|
+
@pulumi.getter(name="jfcV1")
|
|
2503
|
+
def jfc_v1(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2504
|
+
"""
|
|
2505
|
+
(Updatable) The BASE64 encoded string of JFR settings XML with schema used by JDK 8.
|
|
2506
|
+
"""
|
|
2507
|
+
return pulumi.get(self, "jfc_v1")
|
|
2508
|
+
|
|
2509
|
+
@jfc_v1.setter
|
|
2510
|
+
def jfc_v1(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2511
|
+
pulumi.set(self, "jfc_v1", value)
|
|
2512
|
+
|
|
2513
|
+
@_builtins.property
|
|
2514
|
+
@pulumi.getter(name="jfcV2")
|
|
2515
|
+
def jfc_v2(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2516
|
+
"""
|
|
2517
|
+
(Updatable) The BASE64 encoded string of JFR settings XML with [schema used by JDK 9 and after](https://raw.githubusercontent.com/openjdk/jdk/master/src/jdk.jfr/share/classes/jdk/jfr/internal/jfc/jfc.xsd).
|
|
2518
|
+
"""
|
|
2519
|
+
return pulumi.get(self, "jfc_v2")
|
|
2520
|
+
|
|
2521
|
+
@jfc_v2.setter
|
|
2522
|
+
def jfc_v2(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2523
|
+
pulumi.set(self, "jfc_v2", value)
|
|
2524
|
+
|
|
2525
|
+
@_builtins.property
|
|
2526
|
+
@pulumi.getter(name="recordingDurationInMinutes")
|
|
2527
|
+
def recording_duration_in_minutes(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2528
|
+
"""
|
|
2529
|
+
(Updatable) Duration of the JFR recording in minutes.
|
|
2530
|
+
"""
|
|
2531
|
+
return pulumi.get(self, "recording_duration_in_minutes")
|
|
2532
|
+
|
|
2533
|
+
@recording_duration_in_minutes.setter
|
|
2534
|
+
def recording_duration_in_minutes(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2535
|
+
pulumi.set(self, "recording_duration_in_minutes", value)
|
|
2536
|
+
|
|
2537
|
+
@_builtins.property
|
|
2538
|
+
@pulumi.getter(name="recordingSizeInMb")
|
|
2539
|
+
def recording_size_in_mb(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2540
|
+
"""
|
|
2541
|
+
(Updatable) The maximum size limit for the JFR file collected.
|
|
2542
|
+
"""
|
|
2543
|
+
return pulumi.get(self, "recording_size_in_mb")
|
|
2544
|
+
|
|
2545
|
+
@recording_size_in_mb.setter
|
|
2546
|
+
def recording_size_in_mb(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2547
|
+
pulumi.set(self, "recording_size_in_mb", value)
|
|
2548
|
+
|
|
2549
|
+
@_builtins.property
|
|
2550
|
+
@pulumi.getter
|
|
2551
|
+
def targets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TaskScheduleTaskDetailsJfrTaskRequestTargetArgs']]]]:
|
|
2552
|
+
"""
|
|
2553
|
+
(Updatable) The attachment targets to start JFR.
|
|
2554
|
+
"""
|
|
2555
|
+
return pulumi.get(self, "targets")
|
|
2556
|
+
|
|
2557
|
+
@targets.setter
|
|
2558
|
+
def targets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TaskScheduleTaskDetailsJfrTaskRequestTargetArgs']]]]):
|
|
2559
|
+
pulumi.set(self, "targets", value)
|
|
2560
|
+
|
|
2561
|
+
@_builtins.property
|
|
2562
|
+
@pulumi.getter(name="waitingPeriodInMinutes")
|
|
2563
|
+
def waiting_period_in_minutes(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2564
|
+
"""
|
|
2565
|
+
(Updatable) Period to looking for JVMs. In addition to attach to running JVMs when given the command, JVM started within the waiting period will also be attached for JFR. The value should be larger than the agent polling interval setting for the fleet to ensure agent can get the instructions. If not specified, the agent polling interval for the fleet is used.
|
|
2566
|
+
"""
|
|
2567
|
+
return pulumi.get(self, "waiting_period_in_minutes")
|
|
2568
|
+
|
|
2569
|
+
@waiting_period_in_minutes.setter
|
|
2570
|
+
def waiting_period_in_minutes(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2571
|
+
pulumi.set(self, "waiting_period_in_minutes", value)
|
|
2572
|
+
|
|
2573
|
+
|
|
2574
|
+
if not MYPY:
|
|
2575
|
+
class TaskScheduleTaskDetailsJfrTaskRequestTargetArgsDict(TypedDict):
|
|
2576
|
+
application_installation_key: NotRequired[pulumi.Input[_builtins.str]]
|
|
2577
|
+
"""
|
|
2578
|
+
(Updatable) Unique key that identifies the application installation for JFR data collection.
|
|
2579
|
+
"""
|
|
2580
|
+
application_key: NotRequired[pulumi.Input[_builtins.str]]
|
|
2581
|
+
"""
|
|
2582
|
+
(Updatable) Unique key that identifies the application for JFR data collection.
|
|
2583
|
+
"""
|
|
2584
|
+
container_key: NotRequired[pulumi.Input[_builtins.str]]
|
|
2585
|
+
"""
|
|
2586
|
+
(Updatable) Unique key that identifies the container for JFR data collection.
|
|
2587
|
+
"""
|
|
2588
|
+
jre_key: NotRequired[pulumi.Input[_builtins.str]]
|
|
2589
|
+
"""
|
|
2590
|
+
(Updatable) Unique key that identify the JVM for JFR data collection.
|
|
2591
|
+
"""
|
|
2592
|
+
managed_instance_id: NotRequired[pulumi.Input[_builtins.str]]
|
|
2593
|
+
"""
|
|
2594
|
+
(Updatable) OCID of the Managed Instance to collect JFR data.
|
|
2595
|
+
"""
|
|
2596
|
+
elif False:
|
|
2597
|
+
TaskScheduleTaskDetailsJfrTaskRequestTargetArgsDict: TypeAlias = Mapping[str, Any]
|
|
2598
|
+
|
|
2599
|
+
@pulumi.input_type
|
|
2600
|
+
class TaskScheduleTaskDetailsJfrTaskRequestTargetArgs:
|
|
2601
|
+
def __init__(__self__, *,
|
|
2602
|
+
application_installation_key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2603
|
+
application_key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2604
|
+
container_key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2605
|
+
jre_key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2606
|
+
managed_instance_id: Optional[pulumi.Input[_builtins.str]] = None):
|
|
2607
|
+
"""
|
|
2608
|
+
:param pulumi.Input[_builtins.str] application_installation_key: (Updatable) Unique key that identifies the application installation for JFR data collection.
|
|
2609
|
+
:param pulumi.Input[_builtins.str] application_key: (Updatable) Unique key that identifies the application for JFR data collection.
|
|
2610
|
+
:param pulumi.Input[_builtins.str] container_key: (Updatable) Unique key that identifies the container for JFR data collection.
|
|
2611
|
+
:param pulumi.Input[_builtins.str] jre_key: (Updatable) Unique key that identify the JVM for JFR data collection.
|
|
2612
|
+
:param pulumi.Input[_builtins.str] managed_instance_id: (Updatable) OCID of the Managed Instance to collect JFR data.
|
|
2613
|
+
"""
|
|
2614
|
+
if application_installation_key is not None:
|
|
2615
|
+
pulumi.set(__self__, "application_installation_key", application_installation_key)
|
|
2616
|
+
if application_key is not None:
|
|
2617
|
+
pulumi.set(__self__, "application_key", application_key)
|
|
2618
|
+
if container_key is not None:
|
|
2619
|
+
pulumi.set(__self__, "container_key", container_key)
|
|
2620
|
+
if jre_key is not None:
|
|
2621
|
+
pulumi.set(__self__, "jre_key", jre_key)
|
|
2622
|
+
if managed_instance_id is not None:
|
|
2623
|
+
pulumi.set(__self__, "managed_instance_id", managed_instance_id)
|
|
2624
|
+
|
|
2625
|
+
@_builtins.property
|
|
2626
|
+
@pulumi.getter(name="applicationInstallationKey")
|
|
2627
|
+
def application_installation_key(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2628
|
+
"""
|
|
2629
|
+
(Updatable) Unique key that identifies the application installation for JFR data collection.
|
|
2630
|
+
"""
|
|
2631
|
+
return pulumi.get(self, "application_installation_key")
|
|
2632
|
+
|
|
2633
|
+
@application_installation_key.setter
|
|
2634
|
+
def application_installation_key(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2635
|
+
pulumi.set(self, "application_installation_key", value)
|
|
2636
|
+
|
|
2637
|
+
@_builtins.property
|
|
2638
|
+
@pulumi.getter(name="applicationKey")
|
|
2639
|
+
def application_key(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2640
|
+
"""
|
|
2641
|
+
(Updatable) Unique key that identifies the application for JFR data collection.
|
|
2642
|
+
"""
|
|
2643
|
+
return pulumi.get(self, "application_key")
|
|
2644
|
+
|
|
2645
|
+
@application_key.setter
|
|
2646
|
+
def application_key(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2647
|
+
pulumi.set(self, "application_key", value)
|
|
2648
|
+
|
|
2649
|
+
@_builtins.property
|
|
2650
|
+
@pulumi.getter(name="containerKey")
|
|
2651
|
+
def container_key(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2652
|
+
"""
|
|
2653
|
+
(Updatable) Unique key that identifies the container for JFR data collection.
|
|
2654
|
+
"""
|
|
2655
|
+
return pulumi.get(self, "container_key")
|
|
2656
|
+
|
|
2657
|
+
@container_key.setter
|
|
2658
|
+
def container_key(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2659
|
+
pulumi.set(self, "container_key", value)
|
|
2660
|
+
|
|
2661
|
+
@_builtins.property
|
|
2662
|
+
@pulumi.getter(name="jreKey")
|
|
2663
|
+
def jre_key(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2664
|
+
"""
|
|
2665
|
+
(Updatable) Unique key that identify the JVM for JFR data collection.
|
|
2666
|
+
"""
|
|
2667
|
+
return pulumi.get(self, "jre_key")
|
|
2668
|
+
|
|
2669
|
+
@jre_key.setter
|
|
2670
|
+
def jre_key(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2671
|
+
pulumi.set(self, "jre_key", value)
|
|
2672
|
+
|
|
2673
|
+
@_builtins.property
|
|
2674
|
+
@pulumi.getter(name="managedInstanceId")
|
|
2675
|
+
def managed_instance_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2676
|
+
"""
|
|
2677
|
+
(Updatable) OCID of the Managed Instance to collect JFR data.
|
|
2678
|
+
"""
|
|
2679
|
+
return pulumi.get(self, "managed_instance_id")
|
|
2680
|
+
|
|
2681
|
+
@managed_instance_id.setter
|
|
2682
|
+
def managed_instance_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2683
|
+
pulumi.set(self, "managed_instance_id", value)
|
|
2684
|
+
|
|
2685
|
+
|
|
2686
|
+
if not MYPY:
|
|
2687
|
+
class TaskScheduleTaskDetailsPerformanceTuningTaskRequestArgsDict(TypedDict):
|
|
2688
|
+
recording_duration_in_minutes: NotRequired[pulumi.Input[_builtins.int]]
|
|
2689
|
+
"""
|
|
2690
|
+
(Updatable) Duration of the JFR recording in minutes.
|
|
2691
|
+
"""
|
|
2692
|
+
targets: NotRequired[pulumi.Input[Sequence[pulumi.Input['TaskScheduleTaskDetailsPerformanceTuningTaskRequestTargetArgsDict']]]]
|
|
2693
|
+
"""
|
|
2694
|
+
(Updatable) The attachment targets to start JFR.
|
|
2695
|
+
"""
|
|
2696
|
+
waiting_period_in_minutes: NotRequired[pulumi.Input[_builtins.int]]
|
|
2697
|
+
"""
|
|
2698
|
+
(Updatable) Period to looking for JVMs. In addition to attach to running JVMs when given the command, JVM started within the waiting period will also be attached for JFR. The value should be larger than the agent polling interval setting for the fleet to ensure agent can get the instructions. If not specified, the agent polling interval for the fleet is used.
|
|
2699
|
+
"""
|
|
2700
|
+
elif False:
|
|
2701
|
+
TaskScheduleTaskDetailsPerformanceTuningTaskRequestArgsDict: TypeAlias = Mapping[str, Any]
|
|
2702
|
+
|
|
2703
|
+
@pulumi.input_type
|
|
2704
|
+
class TaskScheduleTaskDetailsPerformanceTuningTaskRequestArgs:
|
|
2705
|
+
def __init__(__self__, *,
|
|
2706
|
+
recording_duration_in_minutes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2707
|
+
targets: Optional[pulumi.Input[Sequence[pulumi.Input['TaskScheduleTaskDetailsPerformanceTuningTaskRequestTargetArgs']]]] = None,
|
|
2708
|
+
waiting_period_in_minutes: Optional[pulumi.Input[_builtins.int]] = None):
|
|
2709
|
+
"""
|
|
2710
|
+
:param pulumi.Input[_builtins.int] recording_duration_in_minutes: (Updatable) Duration of the JFR recording in minutes.
|
|
2711
|
+
:param pulumi.Input[Sequence[pulumi.Input['TaskScheduleTaskDetailsPerformanceTuningTaskRequestTargetArgs']]] targets: (Updatable) The attachment targets to start JFR.
|
|
2712
|
+
:param pulumi.Input[_builtins.int] waiting_period_in_minutes: (Updatable) Period to looking for JVMs. In addition to attach to running JVMs when given the command, JVM started within the waiting period will also be attached for JFR. The value should be larger than the agent polling interval setting for the fleet to ensure agent can get the instructions. If not specified, the agent polling interval for the fleet is used.
|
|
2713
|
+
"""
|
|
2714
|
+
if recording_duration_in_minutes is not None:
|
|
2715
|
+
pulumi.set(__self__, "recording_duration_in_minutes", recording_duration_in_minutes)
|
|
2716
|
+
if targets is not None:
|
|
2717
|
+
pulumi.set(__self__, "targets", targets)
|
|
2718
|
+
if waiting_period_in_minutes is not None:
|
|
2719
|
+
pulumi.set(__self__, "waiting_period_in_minutes", waiting_period_in_minutes)
|
|
2720
|
+
|
|
2721
|
+
@_builtins.property
|
|
2722
|
+
@pulumi.getter(name="recordingDurationInMinutes")
|
|
2723
|
+
def recording_duration_in_minutes(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2724
|
+
"""
|
|
2725
|
+
(Updatable) Duration of the JFR recording in minutes.
|
|
2726
|
+
"""
|
|
2727
|
+
return pulumi.get(self, "recording_duration_in_minutes")
|
|
2728
|
+
|
|
2729
|
+
@recording_duration_in_minutes.setter
|
|
2730
|
+
def recording_duration_in_minutes(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2731
|
+
pulumi.set(self, "recording_duration_in_minutes", value)
|
|
2732
|
+
|
|
2733
|
+
@_builtins.property
|
|
2734
|
+
@pulumi.getter
|
|
2735
|
+
def targets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TaskScheduleTaskDetailsPerformanceTuningTaskRequestTargetArgs']]]]:
|
|
2736
|
+
"""
|
|
2737
|
+
(Updatable) The attachment targets to start JFR.
|
|
2738
|
+
"""
|
|
2739
|
+
return pulumi.get(self, "targets")
|
|
2740
|
+
|
|
2741
|
+
@targets.setter
|
|
2742
|
+
def targets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TaskScheduleTaskDetailsPerformanceTuningTaskRequestTargetArgs']]]]):
|
|
2743
|
+
pulumi.set(self, "targets", value)
|
|
2744
|
+
|
|
2745
|
+
@_builtins.property
|
|
2746
|
+
@pulumi.getter(name="waitingPeriodInMinutes")
|
|
2747
|
+
def waiting_period_in_minutes(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2748
|
+
"""
|
|
2749
|
+
(Updatable) Period to looking for JVMs. In addition to attach to running JVMs when given the command, JVM started within the waiting period will also be attached for JFR. The value should be larger than the agent polling interval setting for the fleet to ensure agent can get the instructions. If not specified, the agent polling interval for the fleet is used.
|
|
2750
|
+
"""
|
|
2751
|
+
return pulumi.get(self, "waiting_period_in_minutes")
|
|
2752
|
+
|
|
2753
|
+
@waiting_period_in_minutes.setter
|
|
2754
|
+
def waiting_period_in_minutes(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2755
|
+
pulumi.set(self, "waiting_period_in_minutes", value)
|
|
2756
|
+
|
|
2757
|
+
|
|
2758
|
+
if not MYPY:
|
|
2759
|
+
class TaskScheduleTaskDetailsPerformanceTuningTaskRequestTargetArgsDict(TypedDict):
|
|
2760
|
+
application_installation_key: NotRequired[pulumi.Input[_builtins.str]]
|
|
2761
|
+
"""
|
|
2762
|
+
(Updatable) Unique key that identifies the application installation for JFR data collection.
|
|
2763
|
+
"""
|
|
2764
|
+
application_key: NotRequired[pulumi.Input[_builtins.str]]
|
|
2765
|
+
"""
|
|
2766
|
+
(Updatable) Unique key that identifies the application for JFR data collection.
|
|
2767
|
+
"""
|
|
2768
|
+
container_key: NotRequired[pulumi.Input[_builtins.str]]
|
|
2769
|
+
"""
|
|
2770
|
+
(Updatable) Unique key that identifies the container for JFR data collection.
|
|
2771
|
+
"""
|
|
2772
|
+
jre_key: NotRequired[pulumi.Input[_builtins.str]]
|
|
2773
|
+
"""
|
|
2774
|
+
(Updatable) Unique key that identify the JVM for JFR data collection.
|
|
2775
|
+
"""
|
|
2776
|
+
managed_instance_id: NotRequired[pulumi.Input[_builtins.str]]
|
|
2777
|
+
"""
|
|
2778
|
+
(Updatable) OCID of the Managed Instance to collect JFR data.
|
|
2779
|
+
"""
|
|
2780
|
+
elif False:
|
|
2781
|
+
TaskScheduleTaskDetailsPerformanceTuningTaskRequestTargetArgsDict: TypeAlias = Mapping[str, Any]
|
|
2782
|
+
|
|
2783
|
+
@pulumi.input_type
|
|
2784
|
+
class TaskScheduleTaskDetailsPerformanceTuningTaskRequestTargetArgs:
|
|
2785
|
+
def __init__(__self__, *,
|
|
2786
|
+
application_installation_key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2787
|
+
application_key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2788
|
+
container_key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2789
|
+
jre_key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2790
|
+
managed_instance_id: Optional[pulumi.Input[_builtins.str]] = None):
|
|
2791
|
+
"""
|
|
2792
|
+
:param pulumi.Input[_builtins.str] application_installation_key: (Updatable) Unique key that identifies the application installation for JFR data collection.
|
|
2793
|
+
:param pulumi.Input[_builtins.str] application_key: (Updatable) Unique key that identifies the application for JFR data collection.
|
|
2794
|
+
:param pulumi.Input[_builtins.str] container_key: (Updatable) Unique key that identifies the container for JFR data collection.
|
|
2795
|
+
:param pulumi.Input[_builtins.str] jre_key: (Updatable) Unique key that identify the JVM for JFR data collection.
|
|
2796
|
+
:param pulumi.Input[_builtins.str] managed_instance_id: (Updatable) OCID of the Managed Instance to collect JFR data.
|
|
2797
|
+
"""
|
|
2798
|
+
if application_installation_key is not None:
|
|
2799
|
+
pulumi.set(__self__, "application_installation_key", application_installation_key)
|
|
2800
|
+
if application_key is not None:
|
|
2801
|
+
pulumi.set(__self__, "application_key", application_key)
|
|
2802
|
+
if container_key is not None:
|
|
2803
|
+
pulumi.set(__self__, "container_key", container_key)
|
|
2804
|
+
if jre_key is not None:
|
|
2805
|
+
pulumi.set(__self__, "jre_key", jre_key)
|
|
2806
|
+
if managed_instance_id is not None:
|
|
2807
|
+
pulumi.set(__self__, "managed_instance_id", managed_instance_id)
|
|
2808
|
+
|
|
2809
|
+
@_builtins.property
|
|
2810
|
+
@pulumi.getter(name="applicationInstallationKey")
|
|
2811
|
+
def application_installation_key(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2812
|
+
"""
|
|
2813
|
+
(Updatable) Unique key that identifies the application installation for JFR data collection.
|
|
2814
|
+
"""
|
|
2815
|
+
return pulumi.get(self, "application_installation_key")
|
|
2816
|
+
|
|
2817
|
+
@application_installation_key.setter
|
|
2818
|
+
def application_installation_key(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2819
|
+
pulumi.set(self, "application_installation_key", value)
|
|
2820
|
+
|
|
2821
|
+
@_builtins.property
|
|
2822
|
+
@pulumi.getter(name="applicationKey")
|
|
2823
|
+
def application_key(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2824
|
+
"""
|
|
2825
|
+
(Updatable) Unique key that identifies the application for JFR data collection.
|
|
2826
|
+
"""
|
|
2827
|
+
return pulumi.get(self, "application_key")
|
|
2828
|
+
|
|
2829
|
+
@application_key.setter
|
|
2830
|
+
def application_key(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2831
|
+
pulumi.set(self, "application_key", value)
|
|
2832
|
+
|
|
2833
|
+
@_builtins.property
|
|
2834
|
+
@pulumi.getter(name="containerKey")
|
|
2835
|
+
def container_key(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2836
|
+
"""
|
|
2837
|
+
(Updatable) Unique key that identifies the container for JFR data collection.
|
|
2838
|
+
"""
|
|
2839
|
+
return pulumi.get(self, "container_key")
|
|
2840
|
+
|
|
2841
|
+
@container_key.setter
|
|
2842
|
+
def container_key(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2843
|
+
pulumi.set(self, "container_key", value)
|
|
2844
|
+
|
|
2845
|
+
@_builtins.property
|
|
2846
|
+
@pulumi.getter(name="jreKey")
|
|
2847
|
+
def jre_key(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2848
|
+
"""
|
|
2849
|
+
(Updatable) Unique key that identify the JVM for JFR data collection.
|
|
2850
|
+
"""
|
|
2851
|
+
return pulumi.get(self, "jre_key")
|
|
2852
|
+
|
|
2853
|
+
@jre_key.setter
|
|
2854
|
+
def jre_key(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2855
|
+
pulumi.set(self, "jre_key", value)
|
|
2856
|
+
|
|
2857
|
+
@_builtins.property
|
|
2858
|
+
@pulumi.getter(name="managedInstanceId")
|
|
2859
|
+
def managed_instance_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2860
|
+
"""
|
|
2861
|
+
(Updatable) OCID of the Managed Instance to collect JFR data.
|
|
2862
|
+
"""
|
|
2863
|
+
return pulumi.get(self, "managed_instance_id")
|
|
2864
|
+
|
|
2865
|
+
@managed_instance_id.setter
|
|
2866
|
+
def managed_instance_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2867
|
+
pulumi.set(self, "managed_instance_id", value)
|
|
2868
|
+
|
|
2869
|
+
|
|
2870
|
+
if not MYPY:
|
|
2871
|
+
class TaskScheduleTaskDetailsRemoveInstallationSiteTaskRequestArgsDict(TypedDict):
|
|
2872
|
+
installation_sites: NotRequired[pulumi.Input[Sequence[pulumi.Input['TaskScheduleTaskDetailsRemoveInstallationSiteTaskRequestInstallationSiteArgsDict']]]]
|
|
2873
|
+
"""
|
|
2874
|
+
(Updatable) The list of installation sites to remove.
|
|
2875
|
+
"""
|
|
2876
|
+
elif False:
|
|
2877
|
+
TaskScheduleTaskDetailsRemoveInstallationSiteTaskRequestArgsDict: TypeAlias = Mapping[str, Any]
|
|
2878
|
+
|
|
2879
|
+
@pulumi.input_type
|
|
2880
|
+
class TaskScheduleTaskDetailsRemoveInstallationSiteTaskRequestArgs:
|
|
2881
|
+
def __init__(__self__, *,
|
|
2882
|
+
installation_sites: Optional[pulumi.Input[Sequence[pulumi.Input['TaskScheduleTaskDetailsRemoveInstallationSiteTaskRequestInstallationSiteArgs']]]] = None):
|
|
2883
|
+
"""
|
|
2884
|
+
:param pulumi.Input[Sequence[pulumi.Input['TaskScheduleTaskDetailsRemoveInstallationSiteTaskRequestInstallationSiteArgs']]] installation_sites: (Updatable) The list of installation sites to remove.
|
|
2885
|
+
"""
|
|
2886
|
+
if installation_sites is not None:
|
|
2887
|
+
pulumi.set(__self__, "installation_sites", installation_sites)
|
|
2888
|
+
|
|
2889
|
+
@_builtins.property
|
|
2890
|
+
@pulumi.getter(name="installationSites")
|
|
2891
|
+
def installation_sites(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TaskScheduleTaskDetailsRemoveInstallationSiteTaskRequestInstallationSiteArgs']]]]:
|
|
2892
|
+
"""
|
|
2893
|
+
(Updatable) The list of installation sites to remove.
|
|
2894
|
+
"""
|
|
2895
|
+
return pulumi.get(self, "installation_sites")
|
|
2896
|
+
|
|
2897
|
+
@installation_sites.setter
|
|
2898
|
+
def installation_sites(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TaskScheduleTaskDetailsRemoveInstallationSiteTaskRequestInstallationSiteArgs']]]]):
|
|
2899
|
+
pulumi.set(self, "installation_sites", value)
|
|
2900
|
+
|
|
2901
|
+
|
|
2902
|
+
if not MYPY:
|
|
2903
|
+
class TaskScheduleTaskDetailsRemoveInstallationSiteTaskRequestInstallationSiteArgsDict(TypedDict):
|
|
2904
|
+
installation_key: NotRequired[pulumi.Input[_builtins.str]]
|
|
2905
|
+
"""
|
|
2906
|
+
(Updatable) The unique identifier for the installation of a Java Runtime at a specific path on a specific operating system.
|
|
2907
|
+
"""
|
|
2908
|
+
managed_instance_id: NotRequired[pulumi.Input[_builtins.str]]
|
|
2909
|
+
"""
|
|
2910
|
+
(Updatable) The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the related managed instance.
|
|
2911
|
+
"""
|
|
2912
|
+
elif False:
|
|
2913
|
+
TaskScheduleTaskDetailsRemoveInstallationSiteTaskRequestInstallationSiteArgsDict: TypeAlias = Mapping[str, Any]
|
|
2914
|
+
|
|
2915
|
+
@pulumi.input_type
|
|
2916
|
+
class TaskScheduleTaskDetailsRemoveInstallationSiteTaskRequestInstallationSiteArgs:
|
|
2917
|
+
def __init__(__self__, *,
|
|
2918
|
+
installation_key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2919
|
+
managed_instance_id: Optional[pulumi.Input[_builtins.str]] = None):
|
|
2920
|
+
"""
|
|
2921
|
+
:param pulumi.Input[_builtins.str] installation_key: (Updatable) The unique identifier for the installation of a Java Runtime at a specific path on a specific operating system.
|
|
2922
|
+
:param pulumi.Input[_builtins.str] managed_instance_id: (Updatable) The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the related managed instance.
|
|
2923
|
+
"""
|
|
2924
|
+
if installation_key is not None:
|
|
2925
|
+
pulumi.set(__self__, "installation_key", installation_key)
|
|
2926
|
+
if managed_instance_id is not None:
|
|
2927
|
+
pulumi.set(__self__, "managed_instance_id", managed_instance_id)
|
|
2928
|
+
|
|
2929
|
+
@_builtins.property
|
|
2930
|
+
@pulumi.getter(name="installationKey")
|
|
2931
|
+
def installation_key(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2932
|
+
"""
|
|
2933
|
+
(Updatable) The unique identifier for the installation of a Java Runtime at a specific path on a specific operating system.
|
|
2934
|
+
"""
|
|
2935
|
+
return pulumi.get(self, "installation_key")
|
|
2936
|
+
|
|
2937
|
+
@installation_key.setter
|
|
2938
|
+
def installation_key(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2939
|
+
pulumi.set(self, "installation_key", value)
|
|
2940
|
+
|
|
2941
|
+
@_builtins.property
|
|
2942
|
+
@pulumi.getter(name="managedInstanceId")
|
|
2943
|
+
def managed_instance_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2944
|
+
"""
|
|
2945
|
+
(Updatable) The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the related managed instance.
|
|
2946
|
+
"""
|
|
2947
|
+
return pulumi.get(self, "managed_instance_id")
|
|
2948
|
+
|
|
2949
|
+
@managed_instance_id.setter
|
|
2950
|
+
def managed_instance_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2951
|
+
pulumi.set(self, "managed_instance_id", value)
|
|
2952
|
+
|
|
2953
|
+
|
|
2954
|
+
if not MYPY:
|
|
2955
|
+
class TaskScheduleTaskDetailsScanJavaServerTaskRequestArgsDict(TypedDict):
|
|
2956
|
+
managed_instance_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
2957
|
+
"""
|
|
2958
|
+
(Updatable) The list of [OCIDs](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of managed instances to scan.
|
|
2959
|
+
"""
|
|
2960
|
+
elif False:
|
|
2961
|
+
TaskScheduleTaskDetailsScanJavaServerTaskRequestArgsDict: TypeAlias = Mapping[str, Any]
|
|
2962
|
+
|
|
2963
|
+
@pulumi.input_type
|
|
2964
|
+
class TaskScheduleTaskDetailsScanJavaServerTaskRequestArgs:
|
|
2965
|
+
def __init__(__self__, *,
|
|
2966
|
+
managed_instance_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
|
|
2967
|
+
"""
|
|
2968
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] managed_instance_ids: (Updatable) The list of [OCIDs](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of managed instances to scan.
|
|
2969
|
+
"""
|
|
2970
|
+
if managed_instance_ids is not None:
|
|
2971
|
+
pulumi.set(__self__, "managed_instance_ids", managed_instance_ids)
|
|
2972
|
+
|
|
2973
|
+
@_builtins.property
|
|
2974
|
+
@pulumi.getter(name="managedInstanceIds")
|
|
2975
|
+
def managed_instance_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
2976
|
+
"""
|
|
2977
|
+
(Updatable) The list of [OCIDs](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of managed instances to scan.
|
|
2978
|
+
"""
|
|
2979
|
+
return pulumi.get(self, "managed_instance_ids")
|
|
2980
|
+
|
|
2981
|
+
@managed_instance_ids.setter
|
|
2982
|
+
def managed_instance_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
2983
|
+
pulumi.set(self, "managed_instance_ids", value)
|
|
2984
|
+
|
|
2985
|
+
|
|
2986
|
+
if not MYPY:
|
|
2987
|
+
class TaskScheduleTaskDetailsScanLibraryTaskRequestArgsDict(TypedDict):
|
|
2988
|
+
dynamic_scan_duration_in_minutes: NotRequired[pulumi.Input[_builtins.int]]
|
|
2989
|
+
"""
|
|
2990
|
+
(Updatable) The duration of the dynamic scan in minutes.
|
|
2991
|
+
"""
|
|
2992
|
+
is_dynamic_scan: NotRequired[pulumi.Input[_builtins.bool]]
|
|
2993
|
+
"""
|
|
2994
|
+
(Updatable) Indicates whether the scan is dynamic or static.
|
|
2995
|
+
"""
|
|
2996
|
+
managed_instance_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
2997
|
+
"""
|
|
2998
|
+
(Updatable) The list of [OCIDs](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of managed instances to scan.
|
|
2999
|
+
"""
|
|
3000
|
+
elif False:
|
|
3001
|
+
TaskScheduleTaskDetailsScanLibraryTaskRequestArgsDict: TypeAlias = Mapping[str, Any]
|
|
3002
|
+
|
|
3003
|
+
@pulumi.input_type
|
|
3004
|
+
class TaskScheduleTaskDetailsScanLibraryTaskRequestArgs:
|
|
3005
|
+
def __init__(__self__, *,
|
|
3006
|
+
dynamic_scan_duration_in_minutes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
3007
|
+
is_dynamic_scan: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
3008
|
+
managed_instance_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
|
|
3009
|
+
"""
|
|
3010
|
+
:param pulumi.Input[_builtins.int] dynamic_scan_duration_in_minutes: (Updatable) The duration of the dynamic scan in minutes.
|
|
3011
|
+
:param pulumi.Input[_builtins.bool] is_dynamic_scan: (Updatable) Indicates whether the scan is dynamic or static.
|
|
3012
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] managed_instance_ids: (Updatable) The list of [OCIDs](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of managed instances to scan.
|
|
3013
|
+
"""
|
|
3014
|
+
if dynamic_scan_duration_in_minutes is not None:
|
|
3015
|
+
pulumi.set(__self__, "dynamic_scan_duration_in_minutes", dynamic_scan_duration_in_minutes)
|
|
3016
|
+
if is_dynamic_scan is not None:
|
|
3017
|
+
pulumi.set(__self__, "is_dynamic_scan", is_dynamic_scan)
|
|
3018
|
+
if managed_instance_ids is not None:
|
|
3019
|
+
pulumi.set(__self__, "managed_instance_ids", managed_instance_ids)
|
|
3020
|
+
|
|
3021
|
+
@_builtins.property
|
|
3022
|
+
@pulumi.getter(name="dynamicScanDurationInMinutes")
|
|
3023
|
+
def dynamic_scan_duration_in_minutes(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
3024
|
+
"""
|
|
3025
|
+
(Updatable) The duration of the dynamic scan in minutes.
|
|
3026
|
+
"""
|
|
3027
|
+
return pulumi.get(self, "dynamic_scan_duration_in_minutes")
|
|
3028
|
+
|
|
3029
|
+
@dynamic_scan_duration_in_minutes.setter
|
|
3030
|
+
def dynamic_scan_duration_in_minutes(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
3031
|
+
pulumi.set(self, "dynamic_scan_duration_in_minutes", value)
|
|
3032
|
+
|
|
3033
|
+
@_builtins.property
|
|
3034
|
+
@pulumi.getter(name="isDynamicScan")
|
|
3035
|
+
def is_dynamic_scan(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
3036
|
+
"""
|
|
3037
|
+
(Updatable) Indicates whether the scan is dynamic or static.
|
|
3038
|
+
"""
|
|
3039
|
+
return pulumi.get(self, "is_dynamic_scan")
|
|
3040
|
+
|
|
3041
|
+
@is_dynamic_scan.setter
|
|
3042
|
+
def is_dynamic_scan(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
3043
|
+
pulumi.set(self, "is_dynamic_scan", value)
|
|
3044
|
+
|
|
3045
|
+
@_builtins.property
|
|
3046
|
+
@pulumi.getter(name="managedInstanceIds")
|
|
3047
|
+
def managed_instance_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
3048
|
+
"""
|
|
3049
|
+
(Updatable) The list of [OCIDs](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of managed instances to scan.
|
|
3050
|
+
"""
|
|
3051
|
+
return pulumi.get(self, "managed_instance_ids")
|
|
3052
|
+
|
|
3053
|
+
@managed_instance_ids.setter
|
|
3054
|
+
def managed_instance_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
3055
|
+
pulumi.set(self, "managed_instance_ids", value)
|
|
3056
|
+
|
|
3057
|
+
|
|
1451
3058
|
if not MYPY:
|
|
1452
3059
|
class GetAgentInstallersFilterArgsDict(TypedDict):
|
|
1453
3060
|
name: _builtins.str
|
|
1454
3061
|
values: Sequence[_builtins.str]
|
|
1455
3062
|
regex: NotRequired[_builtins.bool]
|
|
1456
3063
|
elif False:
|
|
1457
|
-
GetAgentInstallersFilterArgsDict: TypeAlias = Mapping[str, Any]
|
|
3064
|
+
GetAgentInstallersFilterArgsDict: TypeAlias = Mapping[str, Any]
|
|
3065
|
+
|
|
3066
|
+
@pulumi.input_type
|
|
3067
|
+
class GetAgentInstallersFilterArgs:
|
|
3068
|
+
def __init__(__self__, *,
|
|
3069
|
+
name: _builtins.str,
|
|
3070
|
+
values: Sequence[_builtins.str],
|
|
3071
|
+
regex: Optional[_builtins.bool] = None):
|
|
3072
|
+
pulumi.set(__self__, "name", name)
|
|
3073
|
+
pulumi.set(__self__, "values", values)
|
|
3074
|
+
if regex is not None:
|
|
3075
|
+
pulumi.set(__self__, "regex", regex)
|
|
3076
|
+
|
|
3077
|
+
@_builtins.property
|
|
3078
|
+
@pulumi.getter
|
|
3079
|
+
def name(self) -> _builtins.str:
|
|
3080
|
+
return pulumi.get(self, "name")
|
|
3081
|
+
|
|
3082
|
+
@name.setter
|
|
3083
|
+
def name(self, value: _builtins.str):
|
|
3084
|
+
pulumi.set(self, "name", value)
|
|
3085
|
+
|
|
3086
|
+
@_builtins.property
|
|
3087
|
+
@pulumi.getter
|
|
3088
|
+
def values(self) -> Sequence[_builtins.str]:
|
|
3089
|
+
return pulumi.get(self, "values")
|
|
3090
|
+
|
|
3091
|
+
@values.setter
|
|
3092
|
+
def values(self, value: Sequence[_builtins.str]):
|
|
3093
|
+
pulumi.set(self, "values", value)
|
|
3094
|
+
|
|
3095
|
+
@_builtins.property
|
|
3096
|
+
@pulumi.getter
|
|
3097
|
+
def regex(self) -> Optional[_builtins.bool]:
|
|
3098
|
+
return pulumi.get(self, "regex")
|
|
3099
|
+
|
|
3100
|
+
@regex.setter
|
|
3101
|
+
def regex(self, value: Optional[_builtins.bool]):
|
|
3102
|
+
pulumi.set(self, "regex", value)
|
|
3103
|
+
|
|
3104
|
+
|
|
3105
|
+
if not MYPY:
|
|
3106
|
+
class GetAnnouncementsFilterArgsDict(TypedDict):
|
|
3107
|
+
name: _builtins.str
|
|
3108
|
+
values: Sequence[_builtins.str]
|
|
3109
|
+
regex: NotRequired[_builtins.bool]
|
|
3110
|
+
elif False:
|
|
3111
|
+
GetAnnouncementsFilterArgsDict: TypeAlias = Mapping[str, Any]
|
|
3112
|
+
|
|
3113
|
+
@pulumi.input_type
|
|
3114
|
+
class GetAnnouncementsFilterArgs:
|
|
3115
|
+
def __init__(__self__, *,
|
|
3116
|
+
name: _builtins.str,
|
|
3117
|
+
values: Sequence[_builtins.str],
|
|
3118
|
+
regex: Optional[_builtins.bool] = None):
|
|
3119
|
+
pulumi.set(__self__, "name", name)
|
|
3120
|
+
pulumi.set(__self__, "values", values)
|
|
3121
|
+
if regex is not None:
|
|
3122
|
+
pulumi.set(__self__, "regex", regex)
|
|
3123
|
+
|
|
3124
|
+
@_builtins.property
|
|
3125
|
+
@pulumi.getter
|
|
3126
|
+
def name(self) -> _builtins.str:
|
|
3127
|
+
return pulumi.get(self, "name")
|
|
3128
|
+
|
|
3129
|
+
@name.setter
|
|
3130
|
+
def name(self, value: _builtins.str):
|
|
3131
|
+
pulumi.set(self, "name", value)
|
|
3132
|
+
|
|
3133
|
+
@_builtins.property
|
|
3134
|
+
@pulumi.getter
|
|
3135
|
+
def values(self) -> Sequence[_builtins.str]:
|
|
3136
|
+
return pulumi.get(self, "values")
|
|
3137
|
+
|
|
3138
|
+
@values.setter
|
|
3139
|
+
def values(self, value: Sequence[_builtins.str]):
|
|
3140
|
+
pulumi.set(self, "values", value)
|
|
3141
|
+
|
|
3142
|
+
@_builtins.property
|
|
3143
|
+
@pulumi.getter
|
|
3144
|
+
def regex(self) -> Optional[_builtins.bool]:
|
|
3145
|
+
return pulumi.get(self, "regex")
|
|
3146
|
+
|
|
3147
|
+
@regex.setter
|
|
3148
|
+
def regex(self, value: Optional[_builtins.bool]):
|
|
3149
|
+
pulumi.set(self, "regex", value)
|
|
3150
|
+
|
|
3151
|
+
|
|
3152
|
+
if not MYPY:
|
|
3153
|
+
class GetFleetBlocklistsFilterArgsDict(TypedDict):
|
|
3154
|
+
name: _builtins.str
|
|
3155
|
+
values: Sequence[_builtins.str]
|
|
3156
|
+
regex: NotRequired[_builtins.bool]
|
|
3157
|
+
elif False:
|
|
3158
|
+
GetFleetBlocklistsFilterArgsDict: TypeAlias = Mapping[str, Any]
|
|
3159
|
+
|
|
3160
|
+
@pulumi.input_type
|
|
3161
|
+
class GetFleetBlocklistsFilterArgs:
|
|
3162
|
+
def __init__(__self__, *,
|
|
3163
|
+
name: _builtins.str,
|
|
3164
|
+
values: Sequence[_builtins.str],
|
|
3165
|
+
regex: Optional[_builtins.bool] = None):
|
|
3166
|
+
pulumi.set(__self__, "name", name)
|
|
3167
|
+
pulumi.set(__self__, "values", values)
|
|
3168
|
+
if regex is not None:
|
|
3169
|
+
pulumi.set(__self__, "regex", regex)
|
|
3170
|
+
|
|
3171
|
+
@_builtins.property
|
|
3172
|
+
@pulumi.getter
|
|
3173
|
+
def name(self) -> _builtins.str:
|
|
3174
|
+
return pulumi.get(self, "name")
|
|
3175
|
+
|
|
3176
|
+
@name.setter
|
|
3177
|
+
def name(self, value: _builtins.str):
|
|
3178
|
+
pulumi.set(self, "name", value)
|
|
3179
|
+
|
|
3180
|
+
@_builtins.property
|
|
3181
|
+
@pulumi.getter
|
|
3182
|
+
def values(self) -> Sequence[_builtins.str]:
|
|
3183
|
+
return pulumi.get(self, "values")
|
|
3184
|
+
|
|
3185
|
+
@values.setter
|
|
3186
|
+
def values(self, value: Sequence[_builtins.str]):
|
|
3187
|
+
pulumi.set(self, "values", value)
|
|
3188
|
+
|
|
3189
|
+
@_builtins.property
|
|
3190
|
+
@pulumi.getter
|
|
3191
|
+
def regex(self) -> Optional[_builtins.bool]:
|
|
3192
|
+
return pulumi.get(self, "regex")
|
|
3193
|
+
|
|
3194
|
+
@regex.setter
|
|
3195
|
+
def regex(self, value: Optional[_builtins.bool]):
|
|
3196
|
+
pulumi.set(self, "regex", value)
|
|
3197
|
+
|
|
3198
|
+
|
|
3199
|
+
if not MYPY:
|
|
3200
|
+
class GetFleetContainersFilterArgsDict(TypedDict):
|
|
3201
|
+
name: _builtins.str
|
|
3202
|
+
values: Sequence[_builtins.str]
|
|
3203
|
+
regex: NotRequired[_builtins.bool]
|
|
3204
|
+
elif False:
|
|
3205
|
+
GetFleetContainersFilterArgsDict: TypeAlias = Mapping[str, Any]
|
|
3206
|
+
|
|
3207
|
+
@pulumi.input_type
|
|
3208
|
+
class GetFleetContainersFilterArgs:
|
|
3209
|
+
def __init__(__self__, *,
|
|
3210
|
+
name: _builtins.str,
|
|
3211
|
+
values: Sequence[_builtins.str],
|
|
3212
|
+
regex: Optional[_builtins.bool] = None):
|
|
3213
|
+
pulumi.set(__self__, "name", name)
|
|
3214
|
+
pulumi.set(__self__, "values", values)
|
|
3215
|
+
if regex is not None:
|
|
3216
|
+
pulumi.set(__self__, "regex", regex)
|
|
3217
|
+
|
|
3218
|
+
@_builtins.property
|
|
3219
|
+
@pulumi.getter
|
|
3220
|
+
def name(self) -> _builtins.str:
|
|
3221
|
+
return pulumi.get(self, "name")
|
|
3222
|
+
|
|
3223
|
+
@name.setter
|
|
3224
|
+
def name(self, value: _builtins.str):
|
|
3225
|
+
pulumi.set(self, "name", value)
|
|
3226
|
+
|
|
3227
|
+
@_builtins.property
|
|
3228
|
+
@pulumi.getter
|
|
3229
|
+
def values(self) -> Sequence[_builtins.str]:
|
|
3230
|
+
return pulumi.get(self, "values")
|
|
3231
|
+
|
|
3232
|
+
@values.setter
|
|
3233
|
+
def values(self, value: Sequence[_builtins.str]):
|
|
3234
|
+
pulumi.set(self, "values", value)
|
|
3235
|
+
|
|
3236
|
+
@_builtins.property
|
|
3237
|
+
@pulumi.getter
|
|
3238
|
+
def regex(self) -> Optional[_builtins.bool]:
|
|
3239
|
+
return pulumi.get(self, "regex")
|
|
3240
|
+
|
|
3241
|
+
@regex.setter
|
|
3242
|
+
def regex(self, value: Optional[_builtins.bool]):
|
|
3243
|
+
pulumi.set(self, "regex", value)
|
|
3244
|
+
|
|
3245
|
+
|
|
3246
|
+
if not MYPY:
|
|
3247
|
+
class GetFleetCryptoAnalysisResultsFilterArgsDict(TypedDict):
|
|
3248
|
+
name: _builtins.str
|
|
3249
|
+
values: Sequence[_builtins.str]
|
|
3250
|
+
regex: NotRequired[_builtins.bool]
|
|
3251
|
+
elif False:
|
|
3252
|
+
GetFleetCryptoAnalysisResultsFilterArgsDict: TypeAlias = Mapping[str, Any]
|
|
3253
|
+
|
|
3254
|
+
@pulumi.input_type
|
|
3255
|
+
class GetFleetCryptoAnalysisResultsFilterArgs:
|
|
3256
|
+
def __init__(__self__, *,
|
|
3257
|
+
name: _builtins.str,
|
|
3258
|
+
values: Sequence[_builtins.str],
|
|
3259
|
+
regex: Optional[_builtins.bool] = None):
|
|
3260
|
+
pulumi.set(__self__, "name", name)
|
|
3261
|
+
pulumi.set(__self__, "values", values)
|
|
3262
|
+
if regex is not None:
|
|
3263
|
+
pulumi.set(__self__, "regex", regex)
|
|
3264
|
+
|
|
3265
|
+
@_builtins.property
|
|
3266
|
+
@pulumi.getter
|
|
3267
|
+
def name(self) -> _builtins.str:
|
|
3268
|
+
return pulumi.get(self, "name")
|
|
3269
|
+
|
|
3270
|
+
@name.setter
|
|
3271
|
+
def name(self, value: _builtins.str):
|
|
3272
|
+
pulumi.set(self, "name", value)
|
|
3273
|
+
|
|
3274
|
+
@_builtins.property
|
|
3275
|
+
@pulumi.getter
|
|
3276
|
+
def values(self) -> Sequence[_builtins.str]:
|
|
3277
|
+
return pulumi.get(self, "values")
|
|
3278
|
+
|
|
3279
|
+
@values.setter
|
|
3280
|
+
def values(self, value: Sequence[_builtins.str]):
|
|
3281
|
+
pulumi.set(self, "values", value)
|
|
3282
|
+
|
|
3283
|
+
@_builtins.property
|
|
3284
|
+
@pulumi.getter
|
|
3285
|
+
def regex(self) -> Optional[_builtins.bool]:
|
|
3286
|
+
return pulumi.get(self, "regex")
|
|
3287
|
+
|
|
3288
|
+
@regex.setter
|
|
3289
|
+
def regex(self, value: Optional[_builtins.bool]):
|
|
3290
|
+
pulumi.set(self, "regex", value)
|
|
3291
|
+
|
|
3292
|
+
|
|
3293
|
+
if not MYPY:
|
|
3294
|
+
class GetFleetDiagnosesFilterArgsDict(TypedDict):
|
|
3295
|
+
name: _builtins.str
|
|
3296
|
+
values: Sequence[_builtins.str]
|
|
3297
|
+
regex: NotRequired[_builtins.bool]
|
|
3298
|
+
elif False:
|
|
3299
|
+
GetFleetDiagnosesFilterArgsDict: TypeAlias = Mapping[str, Any]
|
|
1458
3300
|
|
|
1459
3301
|
@pulumi.input_type
|
|
1460
|
-
class
|
|
3302
|
+
class GetFleetDiagnosesFilterArgs:
|
|
1461
3303
|
def __init__(__self__, *,
|
|
1462
3304
|
name: _builtins.str,
|
|
1463
3305
|
values: Sequence[_builtins.str],
|
|
@@ -1496,15 +3338,15 @@ class GetAgentInstallersFilterArgs:
|
|
|
1496
3338
|
|
|
1497
3339
|
|
|
1498
3340
|
if not MYPY:
|
|
1499
|
-
class
|
|
3341
|
+
class GetFleetDrsFilesFilterArgsDict(TypedDict):
|
|
1500
3342
|
name: _builtins.str
|
|
1501
3343
|
values: Sequence[_builtins.str]
|
|
1502
3344
|
regex: NotRequired[_builtins.bool]
|
|
1503
3345
|
elif False:
|
|
1504
|
-
|
|
3346
|
+
GetFleetDrsFilesFilterArgsDict: TypeAlias = Mapping[str, Any]
|
|
1505
3347
|
|
|
1506
3348
|
@pulumi.input_type
|
|
1507
|
-
class
|
|
3349
|
+
class GetFleetDrsFilesFilterArgs:
|
|
1508
3350
|
def __init__(__self__, *,
|
|
1509
3351
|
name: _builtins.str,
|
|
1510
3352
|
values: Sequence[_builtins.str],
|
|
@@ -1543,15 +3385,15 @@ class GetAnnouncementsFilterArgs:
|
|
|
1543
3385
|
|
|
1544
3386
|
|
|
1545
3387
|
if not MYPY:
|
|
1546
|
-
class
|
|
3388
|
+
class GetFleetErrorAnalyticsFilterArgsDict(TypedDict):
|
|
1547
3389
|
name: _builtins.str
|
|
1548
3390
|
values: Sequence[_builtins.str]
|
|
1549
3391
|
regex: NotRequired[_builtins.bool]
|
|
1550
3392
|
elif False:
|
|
1551
|
-
|
|
3393
|
+
GetFleetErrorAnalyticsFilterArgsDict: TypeAlias = Mapping[str, Any]
|
|
1552
3394
|
|
|
1553
3395
|
@pulumi.input_type
|
|
1554
|
-
class
|
|
3396
|
+
class GetFleetErrorAnalyticsFilterArgs:
|
|
1555
3397
|
def __init__(__self__, *,
|
|
1556
3398
|
name: _builtins.str,
|
|
1557
3399
|
values: Sequence[_builtins.str],
|
|
@@ -1590,15 +3432,15 @@ class GetFleetBlocklistsFilterArgs:
|
|
|
1590
3432
|
|
|
1591
3433
|
|
|
1592
3434
|
if not MYPY:
|
|
1593
|
-
class
|
|
3435
|
+
class GetFleetErrorsFilterArgsDict(TypedDict):
|
|
1594
3436
|
name: _builtins.str
|
|
1595
3437
|
values: Sequence[_builtins.str]
|
|
1596
3438
|
regex: NotRequired[_builtins.bool]
|
|
1597
3439
|
elif False:
|
|
1598
|
-
|
|
3440
|
+
GetFleetErrorsFilterArgsDict: TypeAlias = Mapping[str, Any]
|
|
1599
3441
|
|
|
1600
3442
|
@pulumi.input_type
|
|
1601
|
-
class
|
|
3443
|
+
class GetFleetErrorsFilterArgs:
|
|
1602
3444
|
def __init__(__self__, *,
|
|
1603
3445
|
name: _builtins.str,
|
|
1604
3446
|
values: Sequence[_builtins.str],
|
|
@@ -1637,15 +3479,15 @@ class GetFleetCryptoAnalysisResultsFilterArgs:
|
|
|
1637
3479
|
|
|
1638
3480
|
|
|
1639
3481
|
if not MYPY:
|
|
1640
|
-
class
|
|
3482
|
+
class GetFleetJavaMigrationAnalysisResultsFilterArgsDict(TypedDict):
|
|
1641
3483
|
name: _builtins.str
|
|
1642
3484
|
values: Sequence[_builtins.str]
|
|
1643
3485
|
regex: NotRequired[_builtins.bool]
|
|
1644
3486
|
elif False:
|
|
1645
|
-
|
|
3487
|
+
GetFleetJavaMigrationAnalysisResultsFilterArgsDict: TypeAlias = Mapping[str, Any]
|
|
1646
3488
|
|
|
1647
3489
|
@pulumi.input_type
|
|
1648
|
-
class
|
|
3490
|
+
class GetFleetJavaMigrationAnalysisResultsFilterArgs:
|
|
1649
3491
|
def __init__(__self__, *,
|
|
1650
3492
|
name: _builtins.str,
|
|
1651
3493
|
values: Sequence[_builtins.str],
|
|
@@ -1684,15 +3526,15 @@ class GetFleetDiagnosesFilterArgs:
|
|
|
1684
3526
|
|
|
1685
3527
|
|
|
1686
3528
|
if not MYPY:
|
|
1687
|
-
class
|
|
3529
|
+
class GetFleetLibraryApplicationsFilterArgsDict(TypedDict):
|
|
1688
3530
|
name: _builtins.str
|
|
1689
3531
|
values: Sequence[_builtins.str]
|
|
1690
3532
|
regex: NotRequired[_builtins.bool]
|
|
1691
3533
|
elif False:
|
|
1692
|
-
|
|
3534
|
+
GetFleetLibraryApplicationsFilterArgsDict: TypeAlias = Mapping[str, Any]
|
|
1693
3535
|
|
|
1694
3536
|
@pulumi.input_type
|
|
1695
|
-
class
|
|
3537
|
+
class GetFleetLibraryApplicationsFilterArgs:
|
|
1696
3538
|
def __init__(__self__, *,
|
|
1697
3539
|
name: _builtins.str,
|
|
1698
3540
|
values: Sequence[_builtins.str],
|
|
@@ -1731,15 +3573,15 @@ class GetFleetDrsFilesFilterArgs:
|
|
|
1731
3573
|
|
|
1732
3574
|
|
|
1733
3575
|
if not MYPY:
|
|
1734
|
-
class
|
|
3576
|
+
class GetFleetLibraryManagedInstancesFilterArgsDict(TypedDict):
|
|
1735
3577
|
name: _builtins.str
|
|
1736
3578
|
values: Sequence[_builtins.str]
|
|
1737
3579
|
regex: NotRequired[_builtins.bool]
|
|
1738
3580
|
elif False:
|
|
1739
|
-
|
|
3581
|
+
GetFleetLibraryManagedInstancesFilterArgsDict: TypeAlias = Mapping[str, Any]
|
|
1740
3582
|
|
|
1741
3583
|
@pulumi.input_type
|
|
1742
|
-
class
|
|
3584
|
+
class GetFleetLibraryManagedInstancesFilterArgs:
|
|
1743
3585
|
def __init__(__self__, *,
|
|
1744
3586
|
name: _builtins.str,
|
|
1745
3587
|
values: Sequence[_builtins.str],
|
|
@@ -1778,15 +3620,15 @@ class GetFleetErrorAnalyticsFilterArgs:
|
|
|
1778
3620
|
|
|
1779
3621
|
|
|
1780
3622
|
if not MYPY:
|
|
1781
|
-
class
|
|
3623
|
+
class GetFleetPerformanceTuningAnalysisResultsFilterArgsDict(TypedDict):
|
|
1782
3624
|
name: _builtins.str
|
|
1783
3625
|
values: Sequence[_builtins.str]
|
|
1784
3626
|
regex: NotRequired[_builtins.bool]
|
|
1785
3627
|
elif False:
|
|
1786
|
-
|
|
3628
|
+
GetFleetPerformanceTuningAnalysisResultsFilterArgsDict: TypeAlias = Mapping[str, Any]
|
|
1787
3629
|
|
|
1788
3630
|
@pulumi.input_type
|
|
1789
|
-
class
|
|
3631
|
+
class GetFleetPerformanceTuningAnalysisResultsFilterArgs:
|
|
1790
3632
|
def __init__(__self__, *,
|
|
1791
3633
|
name: _builtins.str,
|
|
1792
3634
|
values: Sequence[_builtins.str],
|
|
@@ -1825,15 +3667,15 @@ class GetFleetErrorsFilterArgs:
|
|
|
1825
3667
|
|
|
1826
3668
|
|
|
1827
3669
|
if not MYPY:
|
|
1828
|
-
class
|
|
3670
|
+
class GetFleetUncorrelatedPackageApplicationsFilterArgsDict(TypedDict):
|
|
1829
3671
|
name: _builtins.str
|
|
1830
3672
|
values: Sequence[_builtins.str]
|
|
1831
3673
|
regex: NotRequired[_builtins.bool]
|
|
1832
3674
|
elif False:
|
|
1833
|
-
|
|
3675
|
+
GetFleetUncorrelatedPackageApplicationsFilterArgsDict: TypeAlias = Mapping[str, Any]
|
|
1834
3676
|
|
|
1835
3677
|
@pulumi.input_type
|
|
1836
|
-
class
|
|
3678
|
+
class GetFleetUncorrelatedPackageApplicationsFilterArgs:
|
|
1837
3679
|
def __init__(__self__, *,
|
|
1838
3680
|
name: _builtins.str,
|
|
1839
3681
|
values: Sequence[_builtins.str],
|
|
@@ -1872,15 +3714,62 @@ class GetFleetJavaMigrationAnalysisResultsFilterArgs:
|
|
|
1872
3714
|
|
|
1873
3715
|
|
|
1874
3716
|
if not MYPY:
|
|
1875
|
-
class
|
|
3717
|
+
class GetFleetUncorrelatedPackageManagedInstancesFilterArgsDict(TypedDict):
|
|
1876
3718
|
name: _builtins.str
|
|
1877
3719
|
values: Sequence[_builtins.str]
|
|
1878
3720
|
regex: NotRequired[_builtins.bool]
|
|
1879
3721
|
elif False:
|
|
1880
|
-
|
|
3722
|
+
GetFleetUncorrelatedPackageManagedInstancesFilterArgsDict: TypeAlias = Mapping[str, Any]
|
|
1881
3723
|
|
|
1882
3724
|
@pulumi.input_type
|
|
1883
|
-
class
|
|
3725
|
+
class GetFleetUncorrelatedPackageManagedInstancesFilterArgs:
|
|
3726
|
+
def __init__(__self__, *,
|
|
3727
|
+
name: _builtins.str,
|
|
3728
|
+
values: Sequence[_builtins.str],
|
|
3729
|
+
regex: Optional[_builtins.bool] = None):
|
|
3730
|
+
pulumi.set(__self__, "name", name)
|
|
3731
|
+
pulumi.set(__self__, "values", values)
|
|
3732
|
+
if regex is not None:
|
|
3733
|
+
pulumi.set(__self__, "regex", regex)
|
|
3734
|
+
|
|
3735
|
+
@_builtins.property
|
|
3736
|
+
@pulumi.getter
|
|
3737
|
+
def name(self) -> _builtins.str:
|
|
3738
|
+
return pulumi.get(self, "name")
|
|
3739
|
+
|
|
3740
|
+
@name.setter
|
|
3741
|
+
def name(self, value: _builtins.str):
|
|
3742
|
+
pulumi.set(self, "name", value)
|
|
3743
|
+
|
|
3744
|
+
@_builtins.property
|
|
3745
|
+
@pulumi.getter
|
|
3746
|
+
def values(self) -> Sequence[_builtins.str]:
|
|
3747
|
+
return pulumi.get(self, "values")
|
|
3748
|
+
|
|
3749
|
+
@values.setter
|
|
3750
|
+
def values(self, value: Sequence[_builtins.str]):
|
|
3751
|
+
pulumi.set(self, "values", value)
|
|
3752
|
+
|
|
3753
|
+
@_builtins.property
|
|
3754
|
+
@pulumi.getter
|
|
3755
|
+
def regex(self) -> Optional[_builtins.bool]:
|
|
3756
|
+
return pulumi.get(self, "regex")
|
|
3757
|
+
|
|
3758
|
+
@regex.setter
|
|
3759
|
+
def regex(self, value: Optional[_builtins.bool]):
|
|
3760
|
+
pulumi.set(self, "regex", value)
|
|
3761
|
+
|
|
3762
|
+
|
|
3763
|
+
if not MYPY:
|
|
3764
|
+
class GetFleetUncorrelatedPackagesFilterArgsDict(TypedDict):
|
|
3765
|
+
name: _builtins.str
|
|
3766
|
+
values: Sequence[_builtins.str]
|
|
3767
|
+
regex: NotRequired[_builtins.bool]
|
|
3768
|
+
elif False:
|
|
3769
|
+
GetFleetUncorrelatedPackagesFilterArgsDict: TypeAlias = Mapping[str, Any]
|
|
3770
|
+
|
|
3771
|
+
@pulumi.input_type
|
|
3772
|
+
class GetFleetUncorrelatedPackagesFilterArgs:
|
|
1884
3773
|
def __init__(__self__, *,
|
|
1885
3774
|
name: _builtins.str,
|
|
1886
3775
|
values: Sequence[_builtins.str],
|
|
@@ -2491,3 +4380,153 @@ class GetPluginErrorsFilterArgs:
|
|
|
2491
4380
|
pulumi.set(self, "regex", value)
|
|
2492
4381
|
|
|
2493
4382
|
|
|
4383
|
+
if not MYPY:
|
|
4384
|
+
class GetTaskSchedulesFilterArgsDict(TypedDict):
|
|
4385
|
+
name: _builtins.str
|
|
4386
|
+
"""
|
|
4387
|
+
The task name.
|
|
4388
|
+
"""
|
|
4389
|
+
values: Sequence[_builtins.str]
|
|
4390
|
+
regex: NotRequired[_builtins.bool]
|
|
4391
|
+
elif False:
|
|
4392
|
+
GetTaskSchedulesFilterArgsDict: TypeAlias = Mapping[str, Any]
|
|
4393
|
+
|
|
4394
|
+
@pulumi.input_type
|
|
4395
|
+
class GetTaskSchedulesFilterArgs:
|
|
4396
|
+
def __init__(__self__, *,
|
|
4397
|
+
name: _builtins.str,
|
|
4398
|
+
values: Sequence[_builtins.str],
|
|
4399
|
+
regex: Optional[_builtins.bool] = None):
|
|
4400
|
+
"""
|
|
4401
|
+
:param _builtins.str name: The task name.
|
|
4402
|
+
"""
|
|
4403
|
+
pulumi.set(__self__, "name", name)
|
|
4404
|
+
pulumi.set(__self__, "values", values)
|
|
4405
|
+
if regex is not None:
|
|
4406
|
+
pulumi.set(__self__, "regex", regex)
|
|
4407
|
+
|
|
4408
|
+
@_builtins.property
|
|
4409
|
+
@pulumi.getter
|
|
4410
|
+
def name(self) -> _builtins.str:
|
|
4411
|
+
"""
|
|
4412
|
+
The task name.
|
|
4413
|
+
"""
|
|
4414
|
+
return pulumi.get(self, "name")
|
|
4415
|
+
|
|
4416
|
+
@name.setter
|
|
4417
|
+
def name(self, value: _builtins.str):
|
|
4418
|
+
pulumi.set(self, "name", value)
|
|
4419
|
+
|
|
4420
|
+
@_builtins.property
|
|
4421
|
+
@pulumi.getter
|
|
4422
|
+
def values(self) -> Sequence[_builtins.str]:
|
|
4423
|
+
return pulumi.get(self, "values")
|
|
4424
|
+
|
|
4425
|
+
@values.setter
|
|
4426
|
+
def values(self, value: Sequence[_builtins.str]):
|
|
4427
|
+
pulumi.set(self, "values", value)
|
|
4428
|
+
|
|
4429
|
+
@_builtins.property
|
|
4430
|
+
@pulumi.getter
|
|
4431
|
+
def regex(self) -> Optional[_builtins.bool]:
|
|
4432
|
+
return pulumi.get(self, "regex")
|
|
4433
|
+
|
|
4434
|
+
@regex.setter
|
|
4435
|
+
def regex(self, value: Optional[_builtins.bool]):
|
|
4436
|
+
pulumi.set(self, "regex", value)
|
|
4437
|
+
|
|
4438
|
+
|
|
4439
|
+
if not MYPY:
|
|
4440
|
+
class GetUtilsJavaMigrationAnalysisFilterArgsDict(TypedDict):
|
|
4441
|
+
name: _builtins.str
|
|
4442
|
+
values: Sequence[_builtins.str]
|
|
4443
|
+
regex: NotRequired[_builtins.bool]
|
|
4444
|
+
elif False:
|
|
4445
|
+
GetUtilsJavaMigrationAnalysisFilterArgsDict: TypeAlias = Mapping[str, Any]
|
|
4446
|
+
|
|
4447
|
+
@pulumi.input_type
|
|
4448
|
+
class GetUtilsJavaMigrationAnalysisFilterArgs:
|
|
4449
|
+
def __init__(__self__, *,
|
|
4450
|
+
name: _builtins.str,
|
|
4451
|
+
values: Sequence[_builtins.str],
|
|
4452
|
+
regex: Optional[_builtins.bool] = None):
|
|
4453
|
+
pulumi.set(__self__, "name", name)
|
|
4454
|
+
pulumi.set(__self__, "values", values)
|
|
4455
|
+
if regex is not None:
|
|
4456
|
+
pulumi.set(__self__, "regex", regex)
|
|
4457
|
+
|
|
4458
|
+
@_builtins.property
|
|
4459
|
+
@pulumi.getter
|
|
4460
|
+
def name(self) -> _builtins.str:
|
|
4461
|
+
return pulumi.get(self, "name")
|
|
4462
|
+
|
|
4463
|
+
@name.setter
|
|
4464
|
+
def name(self, value: _builtins.str):
|
|
4465
|
+
pulumi.set(self, "name", value)
|
|
4466
|
+
|
|
4467
|
+
@_builtins.property
|
|
4468
|
+
@pulumi.getter
|
|
4469
|
+
def values(self) -> Sequence[_builtins.str]:
|
|
4470
|
+
return pulumi.get(self, "values")
|
|
4471
|
+
|
|
4472
|
+
@values.setter
|
|
4473
|
+
def values(self, value: Sequence[_builtins.str]):
|
|
4474
|
+
pulumi.set(self, "values", value)
|
|
4475
|
+
|
|
4476
|
+
@_builtins.property
|
|
4477
|
+
@pulumi.getter
|
|
4478
|
+
def regex(self) -> Optional[_builtins.bool]:
|
|
4479
|
+
return pulumi.get(self, "regex")
|
|
4480
|
+
|
|
4481
|
+
@regex.setter
|
|
4482
|
+
def regex(self, value: Optional[_builtins.bool]):
|
|
4483
|
+
pulumi.set(self, "regex", value)
|
|
4484
|
+
|
|
4485
|
+
|
|
4486
|
+
if not MYPY:
|
|
4487
|
+
class GetUtilsPerformanceTuningAnalysisFilterArgsDict(TypedDict):
|
|
4488
|
+
name: _builtins.str
|
|
4489
|
+
values: Sequence[_builtins.str]
|
|
4490
|
+
regex: NotRequired[_builtins.bool]
|
|
4491
|
+
elif False:
|
|
4492
|
+
GetUtilsPerformanceTuningAnalysisFilterArgsDict: TypeAlias = Mapping[str, Any]
|
|
4493
|
+
|
|
4494
|
+
@pulumi.input_type
|
|
4495
|
+
class GetUtilsPerformanceTuningAnalysisFilterArgs:
|
|
4496
|
+
def __init__(__self__, *,
|
|
4497
|
+
name: _builtins.str,
|
|
4498
|
+
values: Sequence[_builtins.str],
|
|
4499
|
+
regex: Optional[_builtins.bool] = None):
|
|
4500
|
+
pulumi.set(__self__, "name", name)
|
|
4501
|
+
pulumi.set(__self__, "values", values)
|
|
4502
|
+
if regex is not None:
|
|
4503
|
+
pulumi.set(__self__, "regex", regex)
|
|
4504
|
+
|
|
4505
|
+
@_builtins.property
|
|
4506
|
+
@pulumi.getter
|
|
4507
|
+
def name(self) -> _builtins.str:
|
|
4508
|
+
return pulumi.get(self, "name")
|
|
4509
|
+
|
|
4510
|
+
@name.setter
|
|
4511
|
+
def name(self, value: _builtins.str):
|
|
4512
|
+
pulumi.set(self, "name", value)
|
|
4513
|
+
|
|
4514
|
+
@_builtins.property
|
|
4515
|
+
@pulumi.getter
|
|
4516
|
+
def values(self) -> Sequence[_builtins.str]:
|
|
4517
|
+
return pulumi.get(self, "values")
|
|
4518
|
+
|
|
4519
|
+
@values.setter
|
|
4520
|
+
def values(self, value: Sequence[_builtins.str]):
|
|
4521
|
+
pulumi.set(self, "values", value)
|
|
4522
|
+
|
|
4523
|
+
@_builtins.property
|
|
4524
|
+
@pulumi.getter
|
|
4525
|
+
def regex(self) -> Optional[_builtins.bool]:
|
|
4526
|
+
return pulumi.get(self, "regex")
|
|
4527
|
+
|
|
4528
|
+
@regex.setter
|
|
4529
|
+
def regex(self, value: Optional[_builtins.bool]):
|
|
4530
|
+
pulumi.set(self, "regex", value)
|
|
4531
|
+
|
|
4532
|
+
|