Python get_custom_class Examples

Example #1

File: oci_waas_waf_log_facts.py Project: yigitke3/oci-ansible-collection

            "user_agent",
            "protection_rule_key",
        ]
        optional_kwargs = dict(
            (param, self.module.params[param])
            for param in optional_list_method_params
            if self.module.params.get(param) is not None
        )
        return oci_common_utils.list_all_resources(
            self.client.list_waf_logs,
            waas_policy_id=self.module.params.get("waas_policy_id"),
            **optional_kwargs
        )


WafLogFactsHelperCustom = get_custom_class("WafLogFactsHelperCustom")


class ResourceFactsHelper(WafLogFactsHelperCustom, WafLogFactsHelperGen):
    pass


def main():
    module_args = oci_common_utils.get_common_arg_spec()
    module_args.update(
        dict(
            waas_policy_id=dict(type="str", required=True),
            time_observed_greater_than_or_equal_to=dict(type="str"),
            time_observed_less_than=dict(type="str"),
            text_contains=dict(type="str"),
            access_rule_key=dict(type="list"),

Example #2

File: oci_data_science_model_actions.py Project: yigitke3/oci-ansible-collection

            call_fn_kwargs=dict(model_id=self.module.params.get("model_id"),),
            waiter_type=oci_wait_utils.LIFECYCLE_STATE_WAITER_KEY,
            operation="{0}_{1}".format(
                self.module.params.get("action").upper(),
                oci_common_utils.ACTION_OPERATION_KEY,
            ),
            waiter_client=self.get_waiter_client(),
            resource_helper=self,
            wait_for_states=self.get_action_desired_states(
                self.module.params.get("action")
            ),
        )


DataScienceModelActionsHelperCustom = get_custom_class(
    "DataScienceModelActionsHelperCustom"
)


class ResourceHelper(
    DataScienceModelActionsHelperCustom, DataScienceModelActionsHelperGen
):
    pass


def main():
    module_args = oci_common_utils.get_common_arg_spec(
        supports_create=False, supports_wait=True
    )
    module_args.update(
        dict(

Example #3

File: oci_identity_user.py Project: tms7/oci-ansible-collection

    def delete_resource(self):
        return oci_wait_utils.call_and_wait(
            call_fn=self.client.delete_user,
            call_fn_args=(),
            call_fn_kwargs=dict(user_id=self.module.params.get("user_id"), ),
            waiter_type=oci_wait_utils.LIFECYCLE_STATE_WAITER_KEY,
            operation=oci_common_utils.DELETE_OPERATION_KEY,
            waiter_client=self.get_waiter_client(),
            resource_helper=self,
            wait_for_states=self.get_wait_for_states_for_operation(
                oci_common_utils.DELETE_OPERATION_KEY, ),
        )


UserHelperCustom = get_custom_class("UserHelperCustom")


class ResourceHelper(UserHelperCustom, UserHelperGen):
    pass


def main():
    module_args = oci_common_utils.get_common_arg_spec(supports_create=True,
                                                       supports_wait=True)
    module_args.update(
        dict(
            compartment_id=dict(type="str"),
            name=dict(type="str"),
            description=dict(type="str"),
            email=dict(type="str"),

Example #4

File: oci_dns_zone.py Project: yigitke3/oci-ansible-collection

            call_fn_args=(),
            call_fn_kwargs=dict(
                zone_name_or_id=self.module.params.get("zone_name_or_id"),
                if_unmodified_since=self.module.params.get(
                    "if_unmodified_since"),
                compartment_id=self.module.params.get("compartment_id"),
            ),
            waiter_type=oci_wait_utils.LIFECYCLE_STATE_WAITER_KEY,
            operation=oci_common_utils.DELETE_OPERATION_KEY,
            waiter_client=self.get_waiter_client(),
            resource_helper=self,
            wait_for_states=self.get_resource_terminated_states(),
        )


ZoneHelperCustom = get_custom_class("ZoneHelperCustom")


class ResourceHelper(ZoneHelperCustom, ZoneHelperGen):
    pass


def main():
    module_args = oci_common_utils.get_common_arg_spec(supports_create=True,
                                                       supports_wait=True)
    module_args.update(
        dict(
            migration_source=dict(type="str",
                                  default="NONE",
                                  choices=["NONE", "DYNECT"]),
            name=dict(aliases=["zone_name"], type="str"),

Example #5

File: oci_dns_resolver_facts.py Project: lucassrg/oci-ansible-collection

            "display_name",
            "sort_order",
            "sort_by",
            "lifecycle_state",
            "scope",
        ]
        optional_kwargs = dict((param, self.module.params[param])
                               for param in optional_list_method_params
                               if self.module.params.get(param) is not None)
        return oci_common_utils.list_all_resources(
            self.client.list_resolvers,
            compartment_id=self.module.params.get("compartment_id"),
            **optional_kwargs)


ResolverFactsHelperCustom = get_custom_class("ResolverFactsHelperCustom")


class ResourceFactsHelper(ResolverFactsHelperCustom, ResolverFactsHelperGen):
    pass


def main():
    module_args = oci_common_utils.get_common_arg_spec()
    module_args.update(
        dict(
            resolver_id=dict(aliases=["id"], type="str"),
            if_modified_since=dict(type="str"),
            scope=dict(type="str", choices=["GLOBAL", "PRIVATE"]),
            compartment_id=dict(type="str"),
            display_name=dict(aliases=["name"], type="str"),

Example #6

            "name",
            "lifecycle_state",
            "sort_order",
            "sort_by",
            "display_name",
        ]
        optional_kwargs = dict((param, self.module.params[param])
                               for param in optional_list_method_params
                               if self.module.params.get(param) is not None)
        return oci_common_utils.list_all_resources(
            self.client.list_workspaces,
            compartment_id=self.module.params.get("compartment_id"),
            **optional_kwargs)


WorkspaceFactsHelperCustom = get_custom_class("WorkspaceFactsHelperCustom")


class ResourceFactsHelper(WorkspaceFactsHelperCustom, WorkspaceFactsHelperGen):
    pass


def main():
    module_args = oci_common_utils.get_common_arg_spec()
    module_args.update(
        dict(
            workspace_id=dict(aliases=["id"], type="str"),
            compartment_id=dict(type="str"),
            name=dict(type="str"),
            lifecycle_state=dict(
                type="str",

Example #7

            "name",
            "sort_by",
            "sort_order",
            "vault_id",
            "lifecycle_state",
        ]
        optional_kwargs = dict((param, self.module.params[param])
                               for param in optional_list_method_params
                               if self.module.params.get(param) is not None)
        return oci_common_utils.list_all_resources(
            self.client.list_secrets,
            compartment_id=self.module.params.get("compartment_id"),
            **optional_kwargs)


SecretFactsHelperCustom = get_custom_class("SecretFactsHelperCustom")


class ResourceFactsHelper(SecretFactsHelperCustom, SecretFactsHelperGen):
    pass


def main():
    module_args = oci_common_utils.get_common_arg_spec()
    module_args.update(
        dict(
            secret_id=dict(aliases=["id"], type="str"),
            compartment_id=dict(type="str"),
            name=dict(type="str"),
            sort_by=dict(type="str", choices=["TIMECREATED", "NAME"]),
            sort_order=dict(type="str", choices=["ASC", "DESC"]),

Example #8

File: oci_identity_idp_group_mapping.py Project: deton57/oci-ansible-collection

            call_fn=self.client.delete_idp_group_mapping,
            call_fn_args=(),
            call_fn_kwargs=dict(
                identity_provider_id=self.module.params.get(
                    "identity_provider_id"),
                mapping_id=self.module.params.get("mapping_id"),
            ),
            waiter_type=oci_wait_utils.NONE_WAITER_KEY,
            operation=oci_common_utils.DELETE_OPERATION_KEY,
            waiter_client=self.get_waiter_client(),
            resource_helper=self,
            wait_for_states=self.get_resource_terminated_states(),
        )


IdpGroupMappingHelperCustom = get_custom_class("IdpGroupMappingHelperCustom")


class ResourceHelper(IdpGroupMappingHelperCustom, IdpGroupMappingHelperGen):
    pass


def main():
    module_args = oci_common_utils.get_common_arg_spec(supports_create=True,
                                                       supports_wait=True)
    module_args.update(
        dict(
            idp_group_name=dict(type="str"),
            group_id=dict(type="str"),
            identity_provider_id=dict(type="str", required=True),
            mapping_id=dict(aliases=["id"], type="str"),

Example #9

            "vcn_id",
            "display_name",
            "sort_by",
            "sort_order",
            "lifecycle_state",
        ]
        optional_kwargs = dict((param, self.module.params[param])
                               for param in optional_list_method_params
                               if self.module.params.get(param) is not None)
        return oci_common_utils.list_all_resources(
            self.client.list_subnets,
            compartment_id=self.module.params.get("compartment_id"),
            **optional_kwargs)


SubnetFactsHelperCustom = get_custom_class("SubnetFactsHelperCustom")


class ResourceFactsHelper(SubnetFactsHelperCustom, SubnetFactsHelperGen):
    pass


def main():
    module_args = oci_common_utils.get_common_arg_spec()
    module_args.update(
        dict(
            subnet_id=dict(aliases=["id"], type="str"),
            compartment_id=dict(type="str"),
            vcn_id=dict(type="str"),
            display_name=dict(aliases=["name"], type="str"),
            sort_by=dict(type="str", choices=["TIMECREATED", "DISPLAYNAME"]),

Example #10

        return [
            "bulk_action_type",
        ]

    def list_resources(self):
        optional_list_method_params = []
        optional_kwargs = dict((param, self.module.params[param])
                               for param in optional_list_method_params
                               if self.module.params.get(param) is not None)
        return oci_common_utils.list_all_resources(
            self.client.list_bulk_action_resource_types,
            bulk_action_type=self.module.params.get("bulk_action_type"),
            **optional_kwargs)


BulkActionResourceTypeCollectionFactsHelperCustom = get_custom_class(
    "BulkActionResourceTypeCollectionFactsHelperCustom")


class ResourceFactsHelper(
        BulkActionResourceTypeCollectionFactsHelperCustom,
        BulkActionResourceTypeCollectionFactsHelperGen,
):
    pass


def main():
    module_args = oci_common_utils.get_common_arg_spec()
    module_args.update(
        dict(bulk_action_type=dict(
            type="str",
            required=True,

Example #11

File: oci_network_vcn_topology_facts.py Project: oracle/oci-ansible-collection

        optional_get_method_params = [
            "access_level",
            "query_compartment_subtree",
            "cache_control",
        ]
        optional_kwargs = dict((param, self.module.params[param])
                               for param in optional_get_method_params
                               if self.module.params.get(param) is not None)
        return oci_common_utils.call_with_backoff(
            self.client.get_vcn_topology,
            compartment_id=self.module.params.get("compartment_id"),
            vcn_id=self.module.params.get("vcn_id"),
            **optional_kwargs)


VcnTopologyFactsHelperCustom = get_custom_class("VcnTopologyFactsHelperCustom")


class ResourceFactsHelper(VcnTopologyFactsHelperCustom,
                          VcnTopologyFactsHelperGen):
    pass


def main():
    module_args = oci_common_utils.get_common_arg_spec()
    module_args.update(
        dict(
            compartment_id=dict(type="str", required=True),
            vcn_id=dict(type="str", required=True),
            access_level=dict(type="str", choices=["ANY", "ACCESSIBLE"]),
            query_compartment_subtree=dict(type="bool"),

Example #12

File: oci_data_catalog_data_asset_facts.py Project: yigitke3/oci-ansible-collection

            "sort_order",
        ]
        optional_kwargs = dict(
            (param, self.module.params[param])
            for param in optional_list_method_params
            if self.module.params.get(param) is not None
        )
        return oci_common_utils.list_all_resources(
            self.client.list_data_assets,
            catalog_id=self.module.params.get("catalog_id"),
            **optional_kwargs
        )


DataCatalogDataAssetFactsHelperCustom = get_custom_class(
    "DataCatalogDataAssetFactsHelperCustom"
)


class ResourceFactsHelper(
    DataCatalogDataAssetFactsHelperCustom, DataCatalogDataAssetFactsHelperGen
):
    pass


def main():
    module_args = oci_common_utils.get_common_arg_spec()
    module_args.update(
        dict(
            catalog_id=dict(type="str", required=True),
            data_asset_key=dict(type="str"),

Example #13

        )

    def delete_resource(self):
        return oci_wait_utils.call_and_wait(
            call_fn=self.client.delete_cpe,
            call_fn_args=(),
            call_fn_kwargs=dict(cpe_id=self.module.params.get("cpe_id"),),
            waiter_type=oci_wait_utils.NONE_WAITER_KEY,
            operation=oci_common_utils.DELETE_OPERATION_KEY,
            waiter_client=self.get_waiter_client(),
            resource_helper=self,
            wait_for_states=self.get_resource_terminated_states(),
        )


CpeHelperCustom = get_custom_class("CpeHelperCustom")


class ResourceHelper(CpeHelperCustom, CpeHelperGen):
    pass


def main():
    module_args = oci_common_utils.get_common_arg_spec(
        supports_create=True, supports_wait=False
    )
    module_args.update(
        dict(
            compartment_id=dict(type="str"),
            defined_tags=dict(type="dict"),
            display_name=dict(aliases=["name"], type="str"),

Example #14

            "lifecycle_state",
        ]
        optional_kwargs = dict(
            (param, self.module.params[param])
            for param in optional_list_method_params
            if self.module.params.get(param) is not None
        )
        return oci_common_utils.list_all_resources(
            self.client.list_vlans,
            compartment_id=self.module.params.get("compartment_id"),
            vcn_id=self.module.params.get("vcn_id"),
            **optional_kwargs
        )


VlanFactsHelperCustom = get_custom_class("VlanFactsHelperCustom")


class ResourceFactsHelper(VlanFactsHelperCustom, VlanFactsHelperGen):
    pass


def main():
    module_args = oci_common_utils.get_common_arg_spec()
    module_args.update(
        dict(
            vlan_id=dict(aliases=["id"], type="str"),
            compartment_id=dict(type="str"),
            vcn_id=dict(type="str"),
            display_name=dict(aliases=["name"], type="str"),
            sort_by=dict(type="str", choices=["TIMECREATED", "DISPLAYNAME"]),

Example #15

            call_fn_args=(),
            call_fn_kwargs=dict(
                namespace_name=self.module.params.get("namespace_name"),
                bucket_name=self.module.params.get("bucket_name"),
                object_name=self.module.params.get("object_name"),
                version_id=self.module.params.get("version_id"),
            ),
            waiter_type=oci_wait_utils.NONE_WAITER_KEY,
            operation=oci_common_utils.DELETE_OPERATION_KEY,
            waiter_client=self.get_waiter_client(),
            resource_helper=self,
            wait_for_states=self.get_resource_terminated_states(),
        )


ObjectHelperCustom = get_custom_class("ObjectHelperCustom")


class ResourceHelper(ObjectHelperCustom, ObjectHelperGen):
    pass


def main():
    module_args = oci_common_utils.get_common_arg_spec(supports_create=False,
                                                       supports_wait=False)
    module_args.update(
        dict(
            namespace_name=dict(type="str", required=True),
            bucket_name=dict(type="str", required=True),
            object_name=dict(type="str", required=True),
            content_length=dict(type="int"),

Example #16

File: oci_network_dhcp_options_actions.py Project: tms7/oci-ansible-collection

                dhcp_id=self.module.params.get("dhcp_id"),
                change_dhcp_options_compartment_details=action_details,
            ),
            waiter_type=oci_wait_utils.NONE_WAITER_KEY,
            operation="{0}_{1}".format(
                self.module.params.get("action").upper(),
                oci_common_utils.ACTION_OPERATION_KEY,
            ),
            waiter_client=self.get_waiter_client(),
            resource_helper=self,
            wait_for_states=self.get_action_desired_states(
                self.module.params.get("action")),
        )


DhcpOptionsActionsHelperCustom = get_custom_class(
    "DhcpOptionsActionsHelperCustom")


class ResourceHelper(DhcpOptionsActionsHelperCustom,
                     DhcpOptionsActionsHelperGen):
    pass


def main():
    module_args = oci_common_utils.get_common_arg_spec(supports_create=False,
                                                       supports_wait=False)
    module_args.update(
        dict(
            dhcp_id=dict(aliases=["id"], type="str", required=True),
            compartment_id=dict(type="str", required=True),
            action=dict(type="str",

Example #17

    def create_resource(self):
        create_details = self.get_create_model()
        return oci_wait_utils.call_and_wait(
            call_fn=self.client.generate_data_encryption_key,
            call_fn_args=(),
            call_fn_kwargs=dict(generate_key_details=create_details, ),
            waiter_type=oci_wait_utils.NONE_WAITER_KEY,
            operation=oci_common_utils.CREATE_OPERATION_KEY,
            waiter_client=self.client,
            resource_helper=self,
            wait_for_states=self.get_resource_active_states(),
        )


GeneratedKeyHelperCustom = get_custom_class("GeneratedKeyHelperCustom")


class ResourceHelper(GeneratedKeyHelperCustom, GeneratedKeyHelperGen):
    pass


def main():
    module_args = oci_common_utils.get_common_arg_spec(supports_create=True,
                                                       supports_wait=False)
    module_args.update(
        dict(
            associated_data=dict(type="dict"),
            include_plaintext_key=dict(type="bool", required=True),
            key_id=dict(type="str", required=True),
            key_shape=dict(

Example #18

class AnnouncementFactsHelperGen(OCIResourceFactsHelperBase):
    """Supported operations: get"""
    def get_required_params_for_get(self):
        return [
            "announcement_id",
        ]

    def get_resource(self):
        return oci_common_utils.call_with_backoff(
            self.client.get_announcement,
            announcement_id=self.module.params.get("announcement_id"),
        )


AnnouncementFactsHelperCustom = get_custom_class(
    "AnnouncementFactsHelperCustom")


class ResourceFactsHelper(AnnouncementFactsHelperCustom,
                          AnnouncementFactsHelperGen):
    pass


def main():
    module_args = oci_common_utils.get_common_arg_spec()
    module_args.update(
        dict(announcement_id=dict(aliases=["id"], type="str",
                                  required=True), ))

    module = AnsibleModule(argument_spec=module_args)

Example #19

    def delete_resource(self):
        return oci_wait_utils.call_and_wait(
            call_fn=self.client.delete_cluster,
            call_fn_args=(),
            call_fn_kwargs=dict(
                cluster_id=self.module.params.get("cluster_id"), ),
            waiter_type=oci_wait_utils.WORK_REQUEST_WAITER_KEY,
            operation=oci_common_utils.DELETE_OPERATION_KEY,
            waiter_client=self.get_waiter_client(),
            resource_helper=self,
            wait_for_states=oci_common_utils.get_work_request_completed_states(
            ),
        )


ClusterHelperCustom = get_custom_class("ClusterHelperCustom")


class ResourceHelper(ClusterHelperCustom, ClusterHelperGen):
    pass


def main():
    module_args = oci_common_utils.get_common_arg_spec(supports_create=True,
                                                       supports_wait=True)
    module_args.update(
        dict(
            name=dict(type="str"),
            compartment_id=dict(type="str"),
            vcn_id=dict(type="str"),
            kubernetes_version=dict(type="str"),

Example #20

            "display_name",
        ]
        optional_kwargs = dict(
            (param, self.module.params[param])
            for param in optional_list_method_params
            if self.module.params.get(param) is not None
        )
        return oci_common_utils.list_all_resources(
            self.client.list_boot_volumes,
            availability_domain=self.module.params.get("availability_domain"),
            compartment_id=self.module.params.get("compartment_id"),
            **optional_kwargs
        )


BootVolumeFactsHelperCustom = get_custom_class("BootVolumeFactsHelperCustom")


class ResourceFactsHelper(BootVolumeFactsHelperCustom, BootVolumeFactsHelperGen):
    pass


def main():
    module_args = oci_common_utils.get_common_arg_spec()
    module_args.update(
        dict(
            boot_volume_id=dict(aliases=["id"], type="str"),
            availability_domain=dict(type="str"),
            compartment_id=dict(type="str"),
            volume_group_id=dict(type="str"),
            display_name=dict(type="str"),

Example #21

        optional_list_method_params = [
            "compartment_id",
            "image_id",
            "display_name",
            "sort_by",
            "sort_order",
        ]
        optional_kwargs = dict((param, self.module.params[param])
                               for param in optional_list_method_params
                               if self.module.params.get(param) is not None)
        return oci_common_utils.list_all_resources(
            self.client.list_compute_image_capability_schemas,
            **optional_kwargs)


ComputeImageCapabilitySchemaFactsHelperCustom = get_custom_class(
    "ComputeImageCapabilitySchemaFactsHelperCustom")


class ResourceFactsHelper(
        ComputeImageCapabilitySchemaFactsHelperCustom,
        ComputeImageCapabilitySchemaFactsHelperGen,
):
    pass


def main():
    module_args = oci_common_utils.get_common_arg_spec()
    module_args.update(
        dict(
            compute_image_capability_schema_id=dict(aliases=["id"],
                                                    type="str"),

Example #22

        OCIResourceFactsHelperBase):
    """Supported operations: get"""
    def get_required_params_for_get(self):
        return [
            "autonomous_exadata_infrastructure_id",
        ]

    def get_resource(self):
        return oci_common_utils.call_with_backoff(
            self.client.get_exadata_infrastructure_ocpus,
            autonomous_exadata_infrastructure_id=self.module.params.get(
                "autonomous_exadata_infrastructure_id"),
        )


AutonomousExadataInfrastructureOcpusFactsHelperCustom = get_custom_class(
    "AutonomousExadataInfrastructureOcpusFactsHelperCustom")


class ResourceFactsHelper(
        AutonomousExadataInfrastructureOcpusFactsHelperCustom,
        AutonomousExadataInfrastructureOcpusFactsHelperGen,
):
    pass


def main():
    module_args = oci_common_utils.get_common_arg_spec()
    module_args.update(
        dict(autonomous_exadata_infrastructure_id=dict(aliases=["id"],
                                                       type="str",
                                                       required=True), ))

Example #23

File: oci_blockstorage_boot_volume_backup.py Project: khaledMohammed000/oci-ansible-collections

    def delete_resource(self):
        return oci_wait_utils.call_and_wait(
            call_fn=self.client.delete_boot_volume_backup,
            call_fn_args=(),
            call_fn_kwargs=dict(
                boot_volume_backup_id=self.module.params.get("boot_volume_backup_id"),
            ),
            waiter_type=oci_wait_utils.LIFECYCLE_STATE_WAITER_KEY,
            operation=oci_common_utils.DELETE_OPERATION_KEY,
            waiter_client=self.client,
            resource_helper=self,
            wait_for_states=self.get_resource_terminated_states(),
        )


BootVolumeBackupHelperCustom = get_custom_class("BootVolumeBackupHelperCustom")


class ResourceHelper(BootVolumeBackupHelperCustom, BootVolumeBackupHelperGen):
    pass


def main():
    module_args = oci_common_utils.get_common_arg_spec(
        supports_create=True, supports_wait=True
    )
    module_args.update(
        dict(
            boot_volume_id=dict(type="str"),
            defined_tags=dict(type="dict"),
            display_name=dict(aliases=["name"], type="str"),

Example #24

        return [
            "cpe_id",
        ]

    def get_resource(self):
        return oci_common_utils.call_with_backoff(
            self.client.get_cpe_device_config_content,
            cpe_id=self.module.params.get("cpe_id"),
        )

    def get(self):
        response_data = self.get_resource().data
        return to_text(response_data)


CpeConfigContentFactsHelperCustom = get_custom_class(
    "CpeConfigContentFactsHelperCustom")


class ResourceFactsHelper(CpeConfigContentFactsHelperCustom,
                          CpeConfigContentFactsHelperGen):
    pass


def main():
    module_args = oci_common_utils.get_common_arg_spec()
    module_args.update(
        dict(cpe_id=dict(aliases=["id"], type="str", required=True), ))

    module = AnsibleModule(argument_spec=module_args)

    if not HAS_OCI_PY_SDK:

Example #25

File: oci_loadbalancer_health_facts.py Project: lucassrg/oci-ansible-collection

            self.client.get_load_balancer_health,
            load_balancer_id=self.module.params.get("load_balancer_id"),
        )

    def list_resources(self):
        optional_list_method_params = []
        optional_kwargs = dict((param, self.module.params[param])
                               for param in optional_list_method_params
                               if self.module.params.get(param) is not None)
        return oci_common_utils.list_all_resources(
            self.client.list_load_balancer_healths,
            compartment_id=self.module.params.get("compartment_id"),
            **optional_kwargs)


LoadBalancerHealthFactsHelperCustom = get_custom_class(
    "LoadBalancerHealthFactsHelperCustom")


class ResourceFactsHelper(LoadBalancerHealthFactsHelperCustom,
                          LoadBalancerHealthFactsHelperGen):
    pass


def main():
    module_args = oci_common_utils.get_common_arg_spec()
    module_args.update(
        dict(
            load_balancer_id=dict(aliases=["id"], type="str"),
            compartment_id=dict(aliases=["id"], type="str"),
        ))

Example #26

File: oci_data_flow_run_facts.py Project: manjushp/oci-ansible-collection

            "lifecycle_state",
            "time_created_greater_than",
            "sort_by",
            "sort_order",
            "display_name",
        ]
        optional_kwargs = dict((param, self.module.params[param])
                               for param in optional_list_method_params
                               if self.module.params.get(param) is not None)
        return oci_common_utils.list_all_resources(
            self.client.list_runs,
            compartment_id=self.module.params.get("compartment_id"),
            **optional_kwargs)


DataFlowRunFactsHelperCustom = get_custom_class("DataFlowRunFactsHelperCustom")


class ResourceFactsHelper(DataFlowRunFactsHelperCustom,
                          DataFlowRunFactsHelperGen):
    pass


def main():
    module_args = oci_common_utils.get_common_arg_spec()
    module_args.update(
        dict(
            run_id=dict(aliases=["id"], type="str"),
            compartment_id=dict(type="str"),
            application_id=dict(type="str"),
            owner_principal_id=dict(type="str"),

Example #27

        return oci_wait_utils.call_and_wait(
            call_fn=self.client.delete_alert_rule,
            call_fn_args=(),
            call_fn_kwargs=dict(
                budget_id=self.module.params.get("budget_id"),
                alert_rule_id=self.module.params.get("alert_rule_id"),
            ),
            waiter_type=oci_wait_utils.NONE_WAITER_KEY,
            operation=oci_common_utils.DELETE_OPERATION_KEY,
            waiter_client=self.client,
            resource_helper=self,
            wait_for_states=self.get_resource_terminated_states(),
        )


BudgetAlertRuleHelperCustom = get_custom_class("BudgetAlertRuleHelperCustom")


class ResourceHelper(BudgetAlertRuleHelperCustom, BudgetAlertRuleHelperGen):
    pass


def main():
    module_args = oci_common_utils.get_common_arg_spec(supports_create=True,
                                                       supports_wait=True)
    module_args.update(
        dict(
            budget_id=dict(type="str", required=True),
            display_name=dict(aliases=["name"], type="str"),
            description=dict(type="str"),
            type=dict(type="str", choices=["ACTUAL", "FORECAST"]),

Example #28

File: oci_ons_subscription.py Project: yigitke3/oci-ansible-collection

    def delete_resource(self):
        return oci_wait_utils.call_and_wait(
            call_fn=self.client.delete_subscription,
            call_fn_args=(),
            call_fn_kwargs=dict(
                subscription_id=self.module.params.get("subscription_id"),
            ),
            waiter_type=oci_wait_utils.LIFECYCLE_STATE_WAITER_KEY,
            operation=oci_common_utils.DELETE_OPERATION_KEY,
            waiter_client=self.get_waiter_client(),
            resource_helper=self,
            wait_for_states=self.get_resource_terminated_states(),
        )


SubscriptionHelperCustom = get_custom_class("SubscriptionHelperCustom")


class ResourceHelper(SubscriptionHelperCustom, SubscriptionHelperGen):
    pass


def main():
    module_args = oci_common_utils.get_common_arg_spec(
        supports_create=True, supports_wait=True
    )
    module_args.update(
        dict(
            topic_id=dict(type="str"),
            compartment_id=dict(type="str"),
            protocol=dict(type="str"),

Example #29

            "utilization_level",
            "confidence",
            "host_name",
            "tablespace_name",
        ]
        optional_kwargs = dict((param, self.module.params[param])
                               for param in optional_get_method_params
                               if self.module.params.get(param) is not None)
        return oci_common_utils.call_with_backoff(
            self.client.summarize_database_insight_resource_forecast_trend,
            compartment_id=self.module.params.get("compartment_id"),
            resource_metric=self.module.params.get("resource_metric"),
            **optional_kwargs)


ResourceForecastTrendFactsHelperCustom = get_custom_class(
    "ResourceForecastTrendFactsHelperCustom")


class ResourceFactsHelper(ResourceForecastTrendFactsHelperCustom,
                          ResourceForecastTrendFactsHelperGen):
    pass


def main():
    module_args = oci_common_utils.get_common_arg_spec()
    module_args.update(
        dict(
            compartment_id=dict(type="str", required=True),
            resource_metric=dict(type="str", required=True),
            analysis_time_interval=dict(type="str"),
            time_interval_start=dict(type="str"),

Example #30

File: oci_bds_instance.py Project: luizcarlos16/oci-ansible-collection

    def delete_resource(self):
        return oci_wait_utils.call_and_wait(
            call_fn=self.client.delete_bds_instance,
            call_fn_args=(),
            call_fn_kwargs=dict(
                bds_instance_id=self.module.params.get("bds_instance_id"), ),
            waiter_type=oci_wait_utils.WORK_REQUEST_WAITER_KEY,
            operation=oci_common_utils.DELETE_OPERATION_KEY,
            waiter_client=self.get_waiter_client(),
            resource_helper=self,
            wait_for_states=oci_common_utils.get_work_request_completed_states(
            ),
        )


BdsInstanceHelperCustom = get_custom_class("BdsInstanceHelperCustom")


class ResourceHelper(BdsInstanceHelperCustom, BdsInstanceHelperGen):
    pass


def main():
    module_args = oci_common_utils.get_common_arg_spec(supports_create=True,
                                                       supports_wait=True)
    module_args.update(
        dict(
            compartment_id=dict(type="str"),
            display_name=dict(aliases=["name"], type="str"),
            cluster_version=dict(type="str"),
            cluster_public_key=dict(type="str"),