heat.engine package

Subpackages

• heat.engine.cfn package
  • Submodules
    • heat.engine.cfn.functions module
      • And
      • Base64
      • Equals
      • FindInMap
      • GetAZs
      • GetAtt
      • If
      • Join
      • MemberListToMap
      • Not
      • Or
      • ParamRef
      • Ref()
      • Replace
      • ResourceFacade
      • Select
      • Split
    • heat.engine.cfn.parameters module
      • CfnParameters
    • heat.engine.cfn.template module
      • CfnTemplate
      • CfnTemplateBase
      • HeatTemplate
  • Module contents
• heat.engine.clients package
  • Subpackages
    • heat.engine.clients.os package
      • Subpackages
      • Submodules
      • Module contents
  • Submodules
    • heat.engine.clients.client_exception module
      • EntityMatchNotFound
      • EntityUniqueMatchNotFound
      • InterfaceNotFound
    • heat.engine.clients.client_plugin module
      • ClientPlugin
      • retry_if_connection_err()
      • retry_if_result_is_false()
    • heat.engine.clients.default_client_plugin module
      • DefaultClientPlugin
    • heat.engine.clients.microversion_mixin module
      • MicroversionMixin
    • heat.engine.clients.progress module
      • ContainerUpdateProgress
      • PoolDeleteProgress
      • ServerCreateProgress
      • ServerDeleteProgress
      • ServerUpdateProgress
      • UpdateProgressBase
      • VolumeAttachProgress
      • VolumeBackupRestoreProgress
      • VolumeDeleteProgress
      • VolumeDetachProgress
      • VolumeResizeProgress
      • VolumeUpdateAccessModeProgress
  • Module contents
    • ClientBackend
    • Clients
    • OpenStackClients
      • OpenStackClients.client()
      • OpenStackClients.client_plugin()
      • OpenStackClients.context
    • has_client()
    • initialise()
    • list_opts()
• heat.engine.constraint package
  • Submodules
    • heat.engine.constraint.common_constraints module
      • CIDRConstraint
      • CRONExpressionConstraint
      • DNSDomainConstraint
      • DNSNameConstraint
      • ExpirationConstraint
      • IPCIDRConstraint
      • IPConstraint
      • ISO8601Constraint
      • JsonStringConstraint
      • MACConstraint
      • RelativeDNSNameConstraint
      • TestConstraintDelay
      • TimezoneConstraint
  • Module contents
• heat.engine.hot package
  • Submodules
    • heat.engine.hot.functions module
      • And
      • ConditionBoolean
      • Contains
      • Digest
      • Equals
      • Filter
      • GetAtt
      • GetAttAllAttributes
      • GetAttThenSelect
      • GetFile
      • GetParam
      • GetResource
      • If
      • IfNullable
      • Join
      • JoinMultiple
      • ListConcat
      • ListConcatUnique
      • MakeURL
      • MapMerge
      • MapReplace
      • Not
      • Or
      • Removed
      • Repeat
      • RepeatWithMap
      • RepeatWithNestedLoop
      • Replace
      • ReplaceJson
      • ReplaceJsonStrict
      • ReplaceJsonVeryStrict
      • ResourceFacade
      • StrSplit
      • Yaql
      • list_opts()
    • heat.engine.hot.parameters module
      • HOTParamSchema
      • HOTParamSchema20170224
      • HOTParamSchema20180302
      • HOTParameters
    • heat.engine.hot.template module
      • HOTemplate20130523
      • HOTemplate20141016
      • HOTemplate20150430
      • HOTemplate20151015
      • HOTemplate20160408
      • HOTemplate20161014
      • HOTemplate20170224
      • HOTemplate20170901
      • HOTemplate20180302
      • HOTemplate20180831
      • HOTemplate20210416
  • Module contents
• heat.engine.notification package
  • Submodules
    • heat.engine.notification.autoscaling module
      • send()
    • heat.engine.notification.stack module
      • send()
  • Module contents
    • get_default_level()
    • list_opts()
    • notify()
• heat.engine.resources package
  • Submodules
    • heat.engine.resources.alarm_base module
      • BaseAlarm
    • heat.engine.resources.scheduler_hints module
      • SchedulerHintsMixin
    • heat.engine.resources.server_base module
      • BaseServer
    • heat.engine.resources.signal_responder module
      • SignalResponder
    • heat.engine.resources.stack_resource module
      • StackResource
    • heat.engine.resources.stack_user module
      • StackUser
    • heat.engine.resources.template_resource module
      • TemplateResource
      • generate_class_from_template()
    • heat.engine.resources.volume_base module
      • BaseVolume
      • BaseVolumeAttachment
    • heat.engine.resources.wait_condition module
      • BaseWaitConditionHandle
      • WaitConditionFailure
      • WaitConditionTimeout
  • Module contents
    • global_env()
    • initialise()
    • list_opts()

Submodules

• heat.engine.api module
  • extract_args()
  • format_event()
  • format_notification_body()
  • format_resource_attributes()
  • format_resource_properties()
  • format_snapshot()
  • format_software_config()
  • format_software_deployment()
  • format_stack()
  • format_stack_db_object()
  • format_stack_output()
  • format_stack_outputs()
  • format_stack_preview()
  • format_stack_resource()
  • format_validate_parameter()
  • format_watch()
  • format_watch_data()
  • translate_filters()
• heat.engine.attributes module
  • Attribute
    • Attribute.as_output()
    • Attribute.support_status()
  • Attributes
    • Attributes.as_outputs()
    • Attributes.cached_attrs
    • Attributes.get_cache_mode()
    • Attributes.has_new_cached_attrs()
    • Attributes.reset_resolved_values()
    • Attributes.schema_from_outputs()
    • Attributes.set_cached_attr()
    • Attributes.set_schema()
  • Schema
    • Schema.BOOLEAN
    • Schema.CACHE_LOCAL
    • Schema.CACHE_MODES
    • Schema.CACHE_NONE
    • Schema.DESCRIPTION
    • Schema.INTEGER
    • Schema.KEYS
    • Schema.LIST
    • Schema.MAP
    • Schema.STRING
    • Schema.TYPE
    • Schema.TYPES
    • Schema.UNKNOWN
    • Schema.from_attribute()
  • schemata()
  • select_from_attribute()
• heat.engine.check_resource module
  • CancelOperation
  • CheckResource
    • CheckResource.check()
    • CheckResource.retrigger_check_resource()
  • check_resource_cleanup()
  • check_resource_update()
  • check_stack_complete()
  • load_resource()
  • propagate_check_resource()
• heat.engine.conditions module
  • Conditions
    • Conditions.is_enabled()
    • Conditions.validate()
• heat.engine.constraints module
  • AllowedPattern
    • AllowedPattern.valid_types
  • AllowedValues
    • AllowedValues.valid_types
  • AnyIndexDict
    • AnyIndexDict.ANYTHING
  • BaseCustomConstraint
    • BaseCustomConstraint.error()
    • BaseCustomConstraint.expected_exceptions
    • BaseCustomConstraint.resource_client_name
    • BaseCustomConstraint.resource_getter_name
    • BaseCustomConstraint.validate()
    • BaseCustomConstraint.validate_with_client()
  • Constraint
    • Constraint.DESCRIPTION
    • Constraint.validate()
  • CustomConstraint
    • CustomConstraint.custom_constraint
    • CustomConstraint.valid_types
  • Length
    • Length.valid_types
  • Modulo
    • Modulo.OFFSET
    • Modulo.STEP
    • Modulo.valid_types
  • Range
    • Range.MAX
    • Range.MIN
    • Range.valid_types
  • Schema
    • Schema.ANY
    • Schema.BOOLEAN
    • Schema.BOOLEAN_TYPE
    • Schema.CONSTRAINTS
    • Schema.DEFAULT
    • Schema.DESCRIPTION
    • Schema.IMMUTABLE
    • Schema.INTEGER
    • Schema.INTEGER_TYPE
    • Schema.KEYS
    • Schema.LIST
    • Schema.LIST_TYPE
    • Schema.MAP
    • Schema.MAP_TYPE
    • Schema.NUMBER
    • Schema.NUMBER_TYPE
    • Schema.REQUIRED
    • Schema.SCHEMA
    • Schema.STRING
    • Schema.STRING_TYPE
    • Schema.TYPE
    • Schema.TYPES
    • Schema.TYPE_KEYS
    • Schema.set_default()
    • Schema.str_to_num()
    • Schema.to_schema_type()
    • Schema.validate()
    • Schema.validate_constraints()
• heat.engine.dependencies module
  • Dependencies
    • Dependencies.graph()
    • Dependencies.leaves()
    • Dependencies.required_by()
    • Dependencies.requires()
    • Dependencies.roots()
    • Dependencies.translate()
  • Graph
    • Graph.copy()
    • Graph.edges()
    • Graph.map()
    • Graph.reverse_copy()
    • Graph.toposort()
  • Node
    • Node.copy()
    • Node.disjoint()
    • Node.require
    • Node.required_by()
    • Node.requires()
    • Node.reverse_copy()
    • Node.satisfy
    • Node.stem()
• heat.engine.environment module
  • ClassResourceInfo
    • ClassResourceInfo.description
    • ClassResourceInfo.get_class()
  • Environment
    • Environment.env_as_dict()
    • Environment.get_class()
    • Environment.get_class_to_instantiate()
    • Environment.get_constraint()
    • Environment.get_event_sinks()
    • Environment.get_resource_info()
    • Environment.get_stack_lifecycle_plugins()
    • Environment.get_types()
    • Environment.load()
    • Environment.register_class()
    • Environment.register_constraint()
    • Environment.register_event_sink()
    • Environment.register_stack_lifecycle_plugin()
    • Environment.user_env_as_dict()
  • GlobResourceInfo
    • GlobResourceInfo.description
    • GlobResourceInfo.get_resource_info()
    • GlobResourceInfo.matches()
  • MapResourceInfo
    • MapResourceInfo.description
    • MapResourceInfo.get_class()
    • MapResourceInfo.get_resource_info()
  • ResourceInfo
    • ResourceInfo.get_class()
    • ResourceInfo.get_class_to_instantiate()
    • ResourceInfo.get_resource_info()
    • ResourceInfo.matches()
    • ResourceInfo.name
    • ResourceInfo.path
    • ResourceInfo.registry
    • ResourceInfo.user_resource
    • ResourceInfo.value
  • ResourceRegistry
    • ResourceRegistry.as_dict()
    • ResourceRegistry.get_class()
    • ResourceRegistry.get_class_to_instantiate()
    • ResourceRegistry.get_resource_info()
    • ResourceRegistry.get_rsrc_restricted_actions()
    • ResourceRegistry.get_types()
    • ResourceRegistry.iterable_by()
    • ResourceRegistry.load()
    • ResourceRegistry.log_resource_info()
    • ResourceRegistry.matches_hook()
    • ResourceRegistry.register_class()
    • ResourceRegistry.remove_item()
    • ResourceRegistry.remove_resources_except()
  • TemplateResourceInfo
    • TemplateResourceInfo.description
    • TemplateResourceInfo.get_class()
    • TemplateResourceInfo.get_class_to_instantiate()
    • TemplateResourceInfo.template_name
  • get_child_environment()
  • is_hook_definition()
  • is_valid_restricted_action()
  • read_global_environment()
  • valid_hook_type()
  • valid_restricted_actions()
• heat.engine.event module
  • Event
    • Event.as_dict()
    • Event.identifier()
    • Event.store()
• heat.engine.function module
  • Function
    • Function.all_dep_attrs()
    • Function.dep_attrs()
    • Function.dependencies()
    • Function.result()
    • Function.stack
    • Function.validate()
  • Invalid
    • Invalid.result()
  • Macro
    • Macro.all_dep_attrs()
    • Macro.dep_attrs()
    • Macro.dependencies()
    • Macro.parse_args()
    • Macro.result()
    • Macro.template
    • Macro.validate()
  • all_dep_attrs()
  • dep_attrs()
  • dependencies()
  • resolve()
  • validate()
• heat.engine.lifecycle_plugin module
  • LifecyclePlugin
    • LifecyclePlugin.do_post_op()
    • LifecyclePlugin.do_pre_op()
    • LifecyclePlugin.get_ordinal()
• heat.engine.node_data module
  • NodeData
    • NodeData.action
    • NodeData.as_dict()
    • NodeData.attribute()
    • NodeData.attribute_names()
    • NodeData.attributes()
    • NodeData.from_dict()
    • NodeData.name
    • NodeData.primary_key
    • NodeData.reference_id()
    • NodeData.status
    • NodeData.uuid
  • load_resources_data()
• heat.engine.output module
  • OutputDefinition
    • OutputDefinition.dep_attrs()
    • OutputDefinition.description()
    • OutputDefinition.get_value()
    • OutputDefinition.render_hot()
    • OutputDefinition.required_resource_names()
    • OutputDefinition.validate()
• heat.engine.parameter_groups module
  • ParameterGroups
    • ParameterGroups.validate()
• heat.engine.parameters module
  • BooleanParam
    • BooleanParam.value()
  • CommaDelimitedListParam
    • CommaDelimitedListParam.default_parsed()
    • CommaDelimitedListParam.parse()
    • CommaDelimitedListParam.value()
  • JsonParam
    • JsonParam.default_parsed()
    • JsonParam.parse()
    • JsonParam.value()
  • NumberParam
    • NumberParam.value()
  • Parameter
    • Parameter.default()
    • Parameter.description()
    • Parameter.has_default()
    • Parameter.has_value()
    • Parameter.hidden()
    • Parameter.label()
    • Parameter.name
    • Parameter.schema
    • Parameter.set_default()
    • Parameter.tags()
    • Parameter.user_default
    • Parameter.user_value
    • Parameter.validate()
    • Parameter.value()
  • Parameters
    • Parameters.immutable_params_modified()
    • Parameters.map()
    • Parameters.set_stack_id()
    • Parameters.validate()
  • ParsedParameter
    • ParsedParameter.parsed
  • Schema
    • Schema.BOOLEAN
    • Schema.CONSTRAINTS
    • Schema.DEFAULT
    • Schema.DESCRIPTION
    • Schema.HIDDEN
    • Schema.IMMUTABLE
    • Schema.KEYS
    • Schema.LABEL
    • Schema.LIST
    • Schema.MAP
    • Schema.NUMBER
    • Schema.PARAMETER_KEYS
    • Schema.SCHEMA
    • Schema.STRING
    • Schema.TAGS
    • Schema.TYPE
    • Schema.TYPES
    • Schema.from_dict()
    • Schema.get_num()
    • Schema.set_default()
    • Schema.validate_value()
  • StringParam
    • StringParam.value()
• heat.engine.parent_rsrc module
  • ParentResourceProxy
    • ParentResourceProxy.metadata_get()
    • ParentResourceProxy.t
  • use_parent_stack()
• heat.engine.plugin_manager module
  • PluginManager
    • PluginManager.map_to_modules()
  • PluginMapping
    • PluginMapping.load_all()
    • PluginMapping.load_from_module()
• heat.engine.properties module
  • Properties
    • Properties.get_user_value()
    • Properties.schema_from_params()
    • Properties.schema_to_parameters_and_properties()
    • Properties.update_translation()
    • Properties.validate()
  • Property
    • Property.default()
    • Property.get_value()
    • Property.has_default()
    • Property.immutable()
    • Property.implemented()
    • Property.make_path()
    • Property.required()
    • Property.support_status()
    • Property.type()
    • Property.update_allowed()
  • Schema
    • Schema.CONSTRAINTS
    • Schema.DEFAULT
    • Schema.DESCRIPTION
    • Schema.IMMUTABLE
    • Schema.KEYS
    • Schema.REQUIRED
    • Schema.SCHEMA
    • Schema.TYPE
    • Schema.UPDATE_ALLOWED
    • Schema.allowed_param_prop_type()
    • Schema.from_legacy()
    • Schema.from_parameter()
    • Schema.validate()
  • schemata()
• heat.engine.properties_group module
  • PropertiesGroup
    • PropertiesGroup.validate_schema()
• heat.engine.resource module
  • NoActionRequired
  • PollDelay
  • Resource
    • Resource.BASE_ATTRIBUTES
    • Resource.FnGetAtt()
    • Resource.FnGetRefId()
    • Resource.LOCK_ACQUIRE
    • Resource.LOCK_ACTIONS
    • Resource.LOCK_NONE
    • Resource.LOCK_RELEASE
    • Resource.LOCK_RESPECT
    • Resource.SHOW
    • Resource.action_handler_task()
    • Resource.add_dependencies()
    • Resource.add_explicit_dependencies()
    • Resource.adopt()
    • Resource.always_replace_on_check_failed
    • Resource.attributes_schema
    • Resource.base_attributes_schema
    • Resource.build_template_dict()
    • Resource.calc_update_allowed()
    • Resource.cancel_grace_period()
    • Resource.check()
    • Resource.check_is_substituted()
    • Resource.cinder()
    • Resource.clear_hook()
    • Resource.clear_stored_attributes()
    • Resource.client()
    • Resource.client_plugin()
    • Resource.create()
    • Resource.create_convergence()
    • Resource.data()
    • Resource.data_delete()
    • Resource.data_set()
    • Resource.default_client_name
    • Resource.delete()
    • Resource.delete_convergence()
    • Resource.delete_snapshot()
    • Resource.destroy()
    • Resource.entity
    • Resource.external_id
    • Resource.frozen_definition()
    • Resource.frozen_properties()
    • Resource.get_attribute()
    • Resource.get_live_resource_data()
    • Resource.get_live_state()
    • Resource.get_nested_parameters_stack()
    • Resource.get_reference_id()
    • Resource.getdoc()
    • Resource.glance()
    • Resource.handle_adopt()
    • Resource.handle_delete()
    • Resource.handle_metadata_reset()
    • Resource.handle_preempt()
    • Resource.handle_update()
    • Resource.has_hook()
    • Resource.has_interface()
    • Resource.has_nested()
    • Resource.heat()
    • Resource.identifier()
    • Resource.is_service_available()
    • Resource.keystone()
    • Resource.load()
    • Resource.lock()
    • Resource.make_replacement()
    • Resource.metadata_get()
    • Resource.metadata_set()
    • Resource.metadata_update()
    • Resource.needs_replace()
    • Resource.needs_replace_failed()
    • Resource.needs_replace_with_prop_diff()
    • Resource.needs_replace_with_tmpl_diff()
    • Resource.neutron()
    • Resource.no_signal_actions
    • Resource.node_data()
    • Resource.nova()
    • Resource.parse_live_resource_data()
    • Resource.pause()
    • Resource.physical_resource_name()
    • Resource.physical_resource_name_limit
    • Resource.physical_resource_name_or_FnGetRefId()
    • Resource.prepare_abandon()
    • Resource.prepare_for_replace()
    • Resource.preview()
    • Resource.preview_update()
    • Resource.reduce_physical_resource_name()
    • Resource.referenced_attrs()
    • Resource.regenerate_info_schema()
    • Resource.reparse()
    • Resource.required_by()
    • Resource.required_service_extension
    • Resource.requires_deferred_auth
    • Resource.resource_id_set()
    • Resource.resource_to_template()
    • Resource.restore_prev_rsrc()
    • Resource.resume()
    • Resource.rpc_client()
    • Resource.signal()
    • Resource.signal_needs_metadata_updates
    • Resource.snapshot()
    • Resource.stack
    • Resource.state
    • Resource.state_reset()
    • Resource.state_set()
    • Resource.store()
    • Resource.store_attributes()
    • Resource.strict_dependency
    • Resource.support_status
    • Resource.suspend()
    • Resource.swift()
    • Resource.translate_properties()
    • Resource.translation_rules()
    • Resource.trigger_hook()
    • Resource.trove()
    • Resource.type()
    • Resource.update()
    • Resource.update_allowed_properties
    • Resource.update_convergence()
    • Resource.update_policy_schema
    • Resource.update_template_diff()
    • Resource.update_template_diff_properties()
    • Resource.validate()
    • Resource.validate_deletion_policy()
    • Resource.validate_external()
    • Resource.validate_template()
• heat.engine.rsrc_defn module
  • ResourceDefinition
    • ResourceDefinition.DELETE
    • ResourceDefinition.DELETION_POLICIES
    • ResourceDefinition.Diff
      • ResourceDefinition.Diff.metadata_changed()
      • ResourceDefinition.Diff.properties_changed()
      • ResourceDefinition.Diff.update_policy_changed()
    • ResourceDefinition.RETAIN
    • ResourceDefinition.SNAPSHOT
    • ResourceDefinition.condition()
    • ResourceDefinition.deletion_policy()
    • ResourceDefinition.dep_attrs()
    • ResourceDefinition.dependencies()
    • ResourceDefinition.external_id()
    • ResourceDefinition.freeze()
    • ResourceDefinition.metadata()
    • ResourceDefinition.properties()
    • ResourceDefinition.render_hot()
    • ResourceDefinition.reparse()
    • ResourceDefinition.required_resource_names()
    • ResourceDefinition.set_translation_rules()
    • ResourceDefinition.update_policy()
    • ResourceDefinition.validate()
• heat.engine.scheduler module
  • DependencyTaskGroup
    • DependencyTaskGroup.cancel_all()
  • ExceptionGroup
  • TaskRunner
    • TaskRunner.as_task()
    • TaskRunner.cancel()
    • TaskRunner.done()
    • TaskRunner.run_to_completion()
    • TaskRunner.start()
    • TaskRunner.started()
    • TaskRunner.step()
  • TimedCancel
    • TimedCancel.trigger()
  • Timeout
    • Timeout.earlier_than()
    • Timeout.expired()
    • Timeout.trigger()
  • task_description()
• heat.engine.service module
  • EngineListener
    • EngineListener.ACTIONS
    • EngineListener.SEND
    • EngineListener.STOP_STACK
    • EngineListener.listening()
    • EngineListener.send()
    • EngineListener.start()
    • EngineListener.stop()
    • EngineListener.stop_stack()
  • EngineService
    • EngineService.RPC_API_VERSION
    • EngineService.abandon_stack()
    • EngineService.authenticated_to_backend()
    • EngineService.check_software_deployment()
    • EngineService.count_stacks()
    • EngineService.create_software_config()
    • EngineService.create_software_deployment()
    • EngineService.create_stack()
    • EngineService.delete_snapshot()
    • EngineService.delete_software_config()
    • EngineService.delete_software_deployment()
    • EngineService.delete_stack()
    • EngineService.describe_stack_resource()
    • EngineService.describe_stack_resources()
    • EngineService.export_stack()
    • EngineService.find_physical_resource()
    • EngineService.generate_template()
    • EngineService.get_environment()
    • EngineService.get_files()
    • EngineService.get_revision()
    • EngineService.get_template()
    • EngineService.identify_stack()
    • EngineService.list_events()
    • EngineService.list_outputs()
    • EngineService.list_resource_types()
    • EngineService.list_services()
    • EngineService.list_software_configs()
    • EngineService.list_software_deployments()
    • EngineService.list_stack_resources()
    • EngineService.list_stacks()
    • EngineService.list_template_functions()
    • EngineService.list_template_versions()
    • EngineService.metadata_software_deployments()
    • EngineService.migrate_convergence_1()
    • EngineService.preview_stack()
    • EngineService.preview_update_stack()
    • EngineService.reset()
    • EngineService.reset_stack_status()
    • EngineService.resource_mark_unhealthy()
    • EngineService.resource_schema()
    • EngineService.resource_signal()
    • EngineService.service_manage_cleanup()
    • EngineService.service_manage_report()
    • EngineService.show_output()
    • EngineService.show_snapshot()
    • EngineService.show_software_config()
    • EngineService.show_software_deployment()
    • EngineService.show_stack()
    • EngineService.signal_software_deployment()
    • EngineService.stack_cancel_update()
    • EngineService.stack_check()
    • EngineService.stack_list_snapshots()
    • EngineService.stack_restore()
    • EngineService.stack_resume()
    • EngineService.stack_snapshot()
    • EngineService.stack_suspend()
    • EngineService.start()
    • EngineService.stop()
    • EngineService.update_software_deployment()
    • EngineService.update_stack()
    • EngineService.validate_template()
    • EngineService.wait()
  • NotifyEvent
    • NotifyEvent.signal()
    • NotifyEvent.signalled()
    • NotifyEvent.wait()
  • ThreadGroup
    • ThreadGroup.add_thread()
  • ThreadGroupManager
    • ThreadGroupManager.add_msg_queue()
    • ThreadGroupManager.add_timer()
    • ThreadGroupManager.remove_msg_queue()
    • ThreadGroupManager.send()
    • ThreadGroupManager.start()
    • ThreadGroupManager.start_with_acquired_lock()
    • ThreadGroupManager.start_with_lock()
    • ThreadGroupManager.stop()
    • ThreadGroupManager.stop_timers()
    • ThreadGroupManager.stopall()
  • ThreadWithCallback
    • ThreadWithCallback.link()
    • ThreadWithCallback.run()
• heat.engine.service_software_config module
  • SoftwareConfigService
    • SoftwareConfigService.check_software_deployment()
    • SoftwareConfigService.count_software_config()
    • SoftwareConfigService.count_software_deployment()
    • SoftwareConfigService.create_software_config()
    • SoftwareConfigService.create_software_deployment()
    • SoftwareConfigService.delete_software_config()
    • SoftwareConfigService.delete_software_deployment()
    • SoftwareConfigService.list_software_configs()
    • SoftwareConfigService.list_software_deployments()
    • SoftwareConfigService.metadata_software_deployments()
    • SoftwareConfigService.show_software_config()
    • SoftwareConfigService.show_software_deployment()
    • SoftwareConfigService.signal_software_deployment()
    • SoftwareConfigService.update_software_deployment()
• heat.engine.software_config_io module
  • IOConfig
    • IOConfig.as_dict()
    • IOConfig.name()
  • InputConfig
    • InputConfig.as_dict()
    • InputConfig.default()
    • InputConfig.input_data()
    • InputConfig.replace_on_change()
    • InputConfig.schema
  • OutputConfig
    • OutputConfig.error_output()
    • OutputConfig.schema
  • check_io_schema_list()
• heat.engine.stack module
  • ConvergenceNode
    • ConvergenceNode.is_update
    • ConvergenceNode.rsrc_id
  • ForcedCancel
  • Stack
    • Stack.ACTIONS
    • Stack.ADOPT
    • Stack.CHECK
    • Stack.COMPLETE
    • Stack.CREATE
    • Stack.DELETE
    • Stack.FAILED
    • Stack.IN_PROGRESS
    • Stack.RESTORE
    • Stack.RESUME
    • Stack.ROLLBACK
    • Stack.SNAPSHOT
    • Stack.STATUSES
    • Stack.SUSPEND
    • Stack.UPDATE
    • Stack.access_allowed()
    • Stack.add_resource()
    • Stack.adopt()
    • Stack.check()
    • Stack.converge_stack()
    • Stack.convergence_dependencies
    • Stack.create()
    • Stack.create_stack_user_project_id()
    • Stack.db_active_resources_get()
    • Stack.db_resource_get()
    • Stack.defer_state_persist()
    • Stack.delete()
    • Stack.delete_all_snapshots()
    • Stack.delete_snapshot()
    • Stack.dependencies
    • Stack.dependent_resource_ids()
    • Stack.dispatch_event()
    • Stack.env
    • Stack.get_availability_zones()
    • Stack.get_kwargs_for_cloning()
    • Stack.get_nested_parameters()
    • Stack.has_timed_out()
    • Stack.identifier()
    • Stack.iter_resources()
    • Stack.load()
    • Stack.load_all()
    • Stack.mark_complete()
    • Stack.mark_failed()
    • Stack.migrate_to_convergence()
    • Stack.object_path_in_stack()
    • Stack.outputs
    • Stack.parameters
    • Stack.parent_resource
    • Stack.parent_resource_name
    • Stack.path_in_stack()
    • Stack.persist_state_and_release_lock()
    • Stack.prepare_abandon()
    • Stack.preview_resources()
    • Stack.purge_db()
    • Stack.register_access_allowed_handler()
    • Stack.remove_resource()
    • Stack.requires_deferred_auth()
    • Stack.reset_dependencies()
    • Stack.reset_stack_and_resources_in_progress()
    • Stack.resource_by_refid()
    • Stack.resource_get()
    • Stack.resources
    • Stack.restore()
    • Stack.restore_data()
    • Stack.resume()
    • Stack.rollback()
    • Stack.root_stack_id()
    • Stack.set_parent_stack()
    • Stack.set_stack_user_project_id()
    • Stack.snapshot()
    • Stack.stack_task()
    • Stack.state
    • Stack.state_set()
    • Stack.store()
    • Stack.stored_context()
    • Stack.supports_check_action()
    • Stack.suspend()
    • Stack.t
    • Stack.tags
    • Stack.time_elapsed()
    • Stack.time_remaining()
    • Stack.timeout_secs()
    • Stack.total_resources()
    • Stack.update()
    • Stack.update_task()
    • Stack.validate()
    • Stack.worker_client
  • reset_state_on_error()
• heat.engine.stack_lock module
  • StackLock
    • StackLock.acquire()
    • StackLock.get_engine_id()
    • StackLock.release()
    • StackLock.thread_lock()
    • StackLock.try_acquire()
    • StackLock.try_thread_lock()
• heat.engine.status module
  • ResourceStatus
    • ResourceStatus.ACTIONS
    • ResourceStatus.ADOPT
    • ResourceStatus.CHECK
    • ResourceStatus.COMPLETE
    • ResourceStatus.CREATE
    • ResourceStatus.DELETE
    • ResourceStatus.FAILED
    • ResourceStatus.INIT
    • ResourceStatus.IN_PROGRESS
    • ResourceStatus.RESUME
    • ResourceStatus.ROLLBACK
    • ResourceStatus.SNAPSHOT
    • ResourceStatus.STATUSES
    • ResourceStatus.SUSPEND
    • ResourceStatus.UPDATE
• heat.engine.stk_defn module
  • ResourceProxy
    • ResourceProxy.FnGetAtt()
    • ResourceProxy.FnGetAtts()
    • ResourceProxy.FnGetRefId()
    • ResourceProxy.action
    • ResourceProxy.attributes_schema
    • ResourceProxy.external_id
    • ResourceProxy.name
    • ResourceProxy.state
    • ResourceProxy.status
    • ResourceProxy.t
  • StackDefinition
    • StackDefinition.all_resource_types()
    • StackDefinition.all_rsrc_names()
    • StackDefinition.clone_with_new_template()
    • StackDefinition.enabled_output_names()
    • StackDefinition.enabled_rsrc_names()
    • StackDefinition.env
    • StackDefinition.get_availability_zones()
    • StackDefinition.output_definition()
    • StackDefinition.parent_resource
    • StackDefinition.resource_definition()
    • StackDefinition.t
  • add_resource()
  • remove_resource()
  • update_resource_data()
• heat.engine.support module
  • SupportStatus
    • SupportStatus.is_substituted()
    • SupportStatus.to_dict()
    • SupportStatus.validate()
  • is_valid_status()
• heat.engine.sync_point module
  • create()
  • delete_all()
  • deserialize_input_data()
  • get()
  • make_key()
  • serialize_input_data()
  • str_pack_tuple()
  • sync()
  • update_input_data()
• heat.engine.template module
  • Template
    • Template.add_output()
    • Template.add_resource()
    • Template.all_param_schemata()
    • Template.condition_functions
    • Template.conditions()
    • Template.create_empty_template()
    • Template.files
    • Template.functions
    • Template.get_section_name()
    • Template.load()
    • Template.merge_snippets()
    • Template.outputs()
    • Template.param_schemata()
    • Template.parameters()
    • Template.parse()
    • Template.parse_condition()
    • Template.remove_all_resources()
    • Template.remove_resource()
    • Template.resource_definitions()
    • Template.store()
    • Template.validate()
• heat.engine.template_common module
  • CommonTemplate
    • CommonTemplate.conditions()
    • CommonTemplate.outputs()
• heat.engine.template_files module
  • ReadOnlyDict
  • TemplateFiles
    • TemplateFiles.store()
    • TemplateFiles.update()
  • get_files_from_container()
• heat.engine.timestamp module
  • Timestamp
• heat.engine.translation module
  • Translation
    • Translation.add()
    • Translation.cast_key_to_rule()
    • Translation.has_translation()
    • Translation.is_deleted()
    • Translation.is_replaced()
    • Translation.replace()
    • Translation.set_rules()
    • Translation.translate()
  • TranslationRule
    • TranslationRule.ADD
    • TranslationRule.DELETE
    • TranslationRule.REPLACE
    • TranslationRule.RESOLVE
    • TranslationRule.RULE_KEYS
    • TranslationRule.get_value_absolute_path()
    • TranslationRule.validate()
  • get_value()
  • resolve_and_find()
• heat.engine.update module
  • StackUpdate
    • StackUpdate.dependencies()
    • StackUpdate.preview()
• heat.engine.worker module
  • WorkerService
    • WorkerService.RPC_API_VERSION
    • WorkerService.cancel_check_resource()
    • WorkerService.check_resource()
    • WorkerService.start()
    • WorkerService.stop()
    • WorkerService.stop_all_workers()
    • WorkerService.stop_traversal()
  • log_exceptions()

Module contents