heat-2014.1/0000775000175400017540000000000012323734470013665 5ustar jenkinsjenkins00000000000000heat-2014.1/HACKING.rst0000664000175400017540000000340012323734123015453 0ustar jenkinsjenkins00000000000000Heat Style Commandments ======================= - Step 1: Read the OpenStack Style Commandments http://docs.openstack.org/developer/hacking/ - Step 2: Read on Heat Specific Commandments -------------------------- None so far Creating Unit Tests ------------------- For every new feature, unit tests should be created that both test and (implicitly) document the usage of said feature. If submitting a patch for a bug that had no unit test, a new passing unit test should be added. If a submitted bug fix does have a unit test, be sure to add a new one that fails without the patch and passes with the patch. For more information on creating unit tests and utilizing the testing infrastructure in OpenStack Heat, please read heat/testing/README.rst. Running Tests ------------- The testing system is based on a combination of tox and testr. The canonical approach to running tests is to simply run the command `tox`. This will create virtual environments, populate them with dependencies and run all of the tests that OpenStack CI systems run. Behind the scenes, tox is running `testr run --parallel`, but is set up such that you can supply any additional testr arguments that are needed to tox. For example, you can run: `tox -- --analyze-isolation` to cause tox to tell testr to add --analyze-isolation to its argument list. It is also possible to run the tests inside of a virtual environment you have created, or it is possible that you have all of the dependencies installed locally already. In this case, you can interact with the testr command directly. Running `testr run` will run the entire test suite. `testr run --parallel` will run it in parallel (this is the default incantation tox uses.) More information about testr can be found at: http://wiki.openstack.org/testr heat-2014.1/CONTRIBUTING.rst0000664000175400017540000000103212323734123016315 0ustar jenkinsjenkins00000000000000If you would like to contribute to the development of OpenStack, you must follow the steps in the "If you're a developer, start here" section of this page: http://wiki.openstack.org/HowToContribute Once those steps have been completed, changes to OpenStack should be submitted for review via the Gerrit tool, following the workflow documented at: http://wiki.openstack.org/GerritWorkflow Pull requests submitted through GitHub will be ignored. Bugs should be filed on Launchpad, not GitHub: https://bugs.launchpad.net/heat heat-2014.1/test-requirements.txt0000664000175400017540000000037212323734126020126 0ustar jenkinsjenkins00000000000000# Hacking already pins down pep8, pyflakes and flake8 hacking>=0.8.0,<0.9 coverage>=3.6 discover mock>=1.0 mox>=0.5.3 testtools>=0.9.34 testrepository>=0.0.18 testscenarios>=0.4 python-glanceclient>=0.9.0 sphinx>=1.1.2,<1.2 oslosphinx lockfile>=0.8 heat-2014.1/.coveragerc0000664000175400017540000000015312323734123016000 0ustar jenkinsjenkins00000000000000[run] branch = True source = heat,contrib omit = */tests/*,heat/openstack/* [report] ignore-errors = True heat-2014.1/ChangeLog0000664000175400017540000044034712323734467015461 0ustar jenkinsjenkins00000000000000CHANGES ======= 2014.1 ------ * Cherry pick oslo-incubator db fixes * Add handle_update to VolumeAttachment * Ensure outputs are resolved for adopted stacks * Pass and use the environment in validate_template * Cherry pick oslo rpc HA fixes * Check top-level sections when parsing a template * Fix timeout for stack actions * Credentials for native heat os-collect-config polling * Allow for stack users in _authorize_stack_user * Fix Jenkins translation jobs * Add a resource_facade intrinsic function to HOT * Resolve data from Resource Facade * Add a default DeletionPolicy for Fn::ResourceFacade * Always answer empty list if deployments not ready * Ensure parameter timeout_mins available in update * Insertion port id in address attribute of server * Disable check_uptodate.sh check in pep8 * Updated from global requirements 2014.1.rc1 ---------- * Properly delete OS::Nova::FloatingIPAssociation * version migration fails if version is an integer * Fix incorrect error msg in validate_template() * Don't log exception for None timeout_mins * Imported Translations from Transifex * Validate that resource type is a string * OS::Nova::Server depend on subnets related to nets * Migrate invalid template version values * Fail if non-existent security group referenced * Order imports in alphabetical order (8/9) * Fix using attributes in unittest * Update heat.conf.sample * Make OS::Nova::Server networks property updatable * Don't catch all exceptions in image constraint * Revert "Add validation to KeyPair resource" * Don't create cloud-init user unless specified * Add docker network_gateway attribute * Change router's prop name agent_id to l3_agent_id * Add subnets as a dependency for router * heat is enabled by default in devstack now * Properly encode heat.common.exception in rpc * Error and NotFound inherit HeatException class * Store stack domain credentials for deployments * Document software config classes * Display container ip not gateway IP * Fix creating docker containers * Fix stack-show failed with a name in uuid format * Reimplement DHCPAgent as net's property * Provide the necessary inputs to enable HEAT_SIGNAL * Implement an identifier stack_path() * Fix heading markup in hot_spec.rst * Using resolving properties for update * Stack identity reads tenant from stack not context * Don't re-bind parameters during stack update * Fix user provider template registration * Add documentation to the firewall properties * Catch NotFound exception on user delete_key * Never specify project_name in keystone v3 auth * Order imports in alphabetical order (7/9) * Propagate files in nested stacks * Get rid of global variable in JSON->YAML conversion * Fix typo in HOT spec * Tolerate None outputs on deployment handle_signal * Add name property to StructuredDeployment * policy.json allow all users to do stacks:lookup * Include environment resource in documentation * Generate local TemplateResource class * Use six.move.xrange to replace xrange * Refactor CLB to work with groups * Add events for automation statuses to Cloud Server * Fix update of Pool's list of HealthMonitors * remove attributes from OS::Heat::AutoScalingGroup * Replacing NetworkGateway when devices updated * Reimplement L3Agent as router's property * Move load_user_creds out of StackWatch * KeyError generated when using a provider template * Devstack getting started, update IMAGE_URLS * Default properties to the empty dict in ResourceGroup * Add space to description of stack_domain_admin * Fix HOT inconsistencies in resource sections * Use stack ID to create domain project name * Modify assert statement when comparing with None * Refactor Template.parse() * Removing unnecessary required=True options * Allow update of disable_rollback * Improve compatibility between Keystone V2 and V3 * Order imports in alphabetical order (6/9) * Order imports in alphabetical order (1/9) * Return template based class in list resource types * Remove unused versions define in template_format.py * Account for stack_user_project_id in stack_get_by_name * Resource type implementations for structured software config * Resource type implementation for software deployment * Remove signal_id from deployments API and model * Server property for software config transport * OS::Nova::Server support for software config * Fix InternalException raised on stack-show * Delete user_creds on stack delete * Add more unit tests for ThreadGroupManager * Fix start_with_acquired_lock - pass kwargs to func * Fix some help strings in common/wsgi.py * migrate User/AccessKey resources to StackUser base class * StackUser add _delete_keypair function * Refactor stack watching into a separate class * Remove decorators for exceptions * Handle 503 response from Nova API * Retry logic for SSH connection in Cloud Server resource * Ensure that the NoCloud data source is loaded, part 2 * Provide attribute schema for waitcondition resource * Fix AccessPolicy update with added resources * Make template formats pluggable * Add an InvalidTemplateVersion exception * Move HOT template code to its own module * Add user_creds_delete to the DB API * fix DB API user_creds_get for non-existent ID * Make user_creds_id a parser.Stack attribute * Fix HOT set_stack_id * heat_keystoneclient don't pass project and trust_id * Fix resolving for Ref function * Add state check when suspend or resume stack * Revert "Showing member list for nested resources" * Allows vip from a different subnet for lbaas resource * Add test for StackUser._create_keypair * StackUser add suspend/resume support * heat_keystoneclient add delete_stack_domain_user_keypair * heat_keystoneclient add legacy fallback path * Fixup uuid stubbing in test_stack_user.py * Move HOT parameters code to a separate module * Load functions from plugins * Use PluginManager to load resources * Add tools/create_heat_domain helper script * Allow handle_signal to assert which actions are valid * Allow getting attributes on suspended resources * Nova server to ref cloud-config resources in user_data * Return None when get_attr cannot resolve a value * Allow proper instance with volume suspension * Add IP address to error message of failed stack * Native ScalingPolicy resource * Remove vim header from files * replace dict comprehension with dict constructor * Implement OS::Neutron::ExtraRoute as /contrib * Always report the action in state_reason as engine encodes it * Convert empty filter dictionary to None * Allow Server name property to be updated * Docs: use the plugin manager to list resources * Move the code that reads the global environment * Add a plugin_manager module * Calculate template version only once * Give cfn a separate Template class * Move HOT version checking to HOTemplate class * Handle API limit exception in nova_utils.refresh_server * Make server resources use nova_utils.refresh_server() * migrate StackUser base class to stack domain users * engine: allow stack_user_project users to retrieve stack * Add config options to specify stack domain admin * Modify stack_user_domain config option to take domain ID * Nova keypair validation breaks client plugins * Add Keystone V2 plugin * Make Keystone client pluggable * Add host_routes property to Neutron subnet resource * Adds Parameter Label to template validate call * Generate docs for contrib plugins * Restructure contrib/ directories * Set statuscode=404 in NotFoundException in tests * Add a validation step to parameters schema * Add admin_pass as a property * Update Oslo wiki link in README * Remove unused variable * I18N support for log message and attributes schema * Change software_config storage of config and io columns * Ensure that the NoCloud data source is loaded * Don't install cloud-init on Rackspace images * Document schema properties for Neutron subnet resource * Document schema properties for Neutron router resources * Add project to unscoped stack list response * Unscoped List Stacks * Alter stack_count_all_by_tenant to stack_count_all * Fix stack_get_all call on stack watcher * Change Resource timestamps to save correct info * Change Stack timestamps to save correct info * SignalResponder move signed URL deleting to its own method * REST deployment metadata method * RPC method to fetch deployments metadata * Fix typo and remove unused code in nova_utils.py * Raise NotFound in software_config_get/software_deployment_get * Docs: use pydoc to read docstrings * Convert AccessKey resource to attributes_schema * Remove redundant FnGetAtt from User resource * Order imports in alphabetical order (3/9) * Check that 'heat_template_version' is a HOT version * Add validation of nested property schema * Replace '+' with string interpolation operation * Remove unused output section from test template * I18N support for error message * Tidy up rpc_client definitions * Updated from global requirements * Adding "device_owner" property for Port resource * Replace hard code in software_deployment REST api * Doc generation display message for deprecated resources * Use property support_status in documentation generation * Use support_status for existing deprecated properties * Remove redundant default value None for dict.get * add OS::Heat::AutoScalingGroup * Fix test for cloud loadbalancer * Add Docker resources to docs * Change Docker resource mapping name * Fix resource mapping for Docker * Changed Openstack into OpenStack in contrib.rst * Move X-Auth-Url logic to auth_url middleware * Add flavor constraint * Rackspace Cloud Networks resource * Fix resource mapping for Rackspace * Add support_status attribute to properties schema * Refactor SupportStatus into its own module * Add ability to create provider networks (vlan,flat) * Move refresh_server() to nova_utils * Add systemd notification support to heat * Order imports in alphabetical order (2/9) * Parse stack_adopt_data * Environment template guide enhancement * Implement glance image constraint * Add neutron network constraint * Remove Fn::FindInMap from HOT * Move built-in functions to separate modules * Disallow Heat-only functions in CloudFormation templates * Provide access to the template version * Move HOT to a separate subpackage * Replace function resolution with lazy evaluation * unit tests: Refactor to accomodate lazy evaluation * unit tests: Fix types in Fn::ResourceFacade tests * Fix test_association_eip unit test * unit tests: Always resolve static functions * Evaluate lazy functions in autoscaling launch config * Server secgroups and network/port together invalid * Replace stack_get_all_by_tenant with stack_get_all * Revert "Merge "Re-enable lazy translation"" * Add Heat API reference to developer docs * Implements resource type NetworkGateway * run_tests.sh default doc omits pep8 * Add preview for LoadBalancer * Add preview for TemplateResource * Add preview for InstanceGroup * Add preview for ResourceGroup * Add preview for NestedStack * Add StackResource specific preview behavior * de-hardcode adjustment type strings in autoscaling * Replace hardcoded schema strings in autoscaling.py * REST API for software deployment * Calculate dependencies based on unresolved template * Re-resolve functions during stack update * Refactor re-resolving of templates * Add a base class for pluggable functions * Prevent user introspection of Python objects * Remove spurious tracebacks from tests, part 2 * Add API support for stack preview * Add engine preview stack with Template and Params * Refactor resource loading functions * Revert config mocking to cfg.CONF.set_override * Remove empty unit test directory * Don't disable SELinux in cloud-init's boothook.sh * Enable usage of custom constraint in parameters * Use six.moves cStringIO instead of cStringIO * Re-enable lazy translation * Fix incompatibilities in tests with keystoneclient 0.6 * Native Nova Server compatibility for Cloud Server * RandomString use the random string as the resource_id * Display max_template_size when a template is too large * Switch over to oslosphinx * Fix usage of resource_data_get_all in stack-abandon * Add validation to KeyPair resource * Rename Openstack to OpenStack * Improve help strings * Add a nova keypair constraint * Use integer when appropriate in autoscaling schema * Fix errors in hot_spec doc * Refactor SignalResponder to abstract user logic * heat_keystoneclient add support to enable/disable domain users * Remove spurious tracebacks from tests * Don't try to stop a stack on a dead engine * Restructure Marconi plugin directory structure * Separate the Marconi client from the resource * Add a requirements file for contrib/rackspace/ * Implement custom constraints * Remove TODO comments in create_resource * REST API for software config * Verify that parsed environment file maps to a dict * Fix misspellings in heat * Add Rackspace resources summary to docs * Delete rackspace database resource * Provide region_name to trove-client * heat_keystoneclient add create_stack_domain_user_keypair * heat_keystoneclient add delete_stack_domain_user function * heat_keystoneclient add create_stack_domain_user function * heat_keystoneclient raise error if stack user role missing * Add parser.Stack support for stack_domain_projects * Change access to ceilometerclient * Imported Translations from Transifex * Add personality files property to Server resource * HOT templates get_param allows extra attributes * Make Server compatible with Nova Key Pair resource * Retrieve user_id from HTTP Headers to populate Context * Rename docker_plugin to docker * Rename Marconi plugin package * Don't raise MySQL 2013 'Lost connection' errors * Adding option in config to specify region name * Add unit tests for heat.scaling.template * Fix default raw_template files value in migration * Move resource_templates to heat.scaling * Refactor _create_template to not rely on instances * Do not log error on software config/deployment NotFound * Handle API 500 response in OS::Nova::Server * Handle API limit exception in OS::Trove::Instance * Adds Parameter Label to HOT spec and parameter schema * Implement HOT intrinsic function get_file * Rename rackspace.rst to contrib.rst * Reorganize docker-plugin for consistency * Restructure Rackspace resources * Delete fixed_ips if it's empty list * Create heat database with default character set utf-8 * Allow an in-progress stack to be deleted * Ensure stack lock is released after stack-delete * Updates template_validate call to validate parameter_groups * Fix indentation errors found by Pep8 1.4.6+ * heat_keystoneclient add support for stack domain projects * New Event uuid column and autoincremental id * tests remove test_heatclient unnecessary mock * RPC service for software config/deployment * A cloud-config resource based on SoftwareConfig * A multipart cloud-init resource based on SoftwareConfig * Resource type for software configuration * Verify setenforce is executable * Implement native signal API * Updated from global requirements * Update heat.conf.sample for python-keystoneclient 0.5.0 * test_signal add missing VerifyAll calls * Translate constraint description in validation * Raise the default max header to accommodate large tokens * Store files in the raw_template table * heat_keystoneclient: abstract admin_client to a property * heat_keystoneclient: Move v3 path logic to constructor * heat_keystoneclient ensure admin client respects SSL options * Make context available during constraint validation * Imported Translations from Transifex * Map the NotFound exception to HTTPNotFound * Only update_and_save if the stack exists * serialize non-string nova metadata * Prevent access Parameters key in template dict * Native Pseudo Parameters * Use a HeatIdentifier instance to create Parameters * HOT templates get_attr allows extra attributes * Fix event_type names for stack CRUD notifications * Purge remaining heat_keystoneclient v2 code * Fix user and signal responder exception import * heat_keystoneclient convert delete_ec2_keypair to v3 API * heat_keystoneclient convert get_ec2_keypair to v3 API * API tolerate None environment string * Fix AWS::StackId pseudo-parameter during stack update * Ensure some properties update_allowed on port res * Don't run pep8 tests with -P * Enabled source code coverage for contrib directory * Fix handle_create of NetDHCPAgent for updating * raw_template hot parameter type data migration * stub cfg.CONF in heat_keystoneclient * Add autoscaling notifications * Refactor Parameters Schema based on common Schema * Move param format for template-validate to API * fix some flaws in heat documents * Add qpid-python to requirements * Marconi message queue resource implementation * Fixes template not using the JSON or YAML format * Add heat.sqlite in git ignore list * Updated from global requirements * Global environment ignores files starting with dot * Refactor software config db model to use LongText * Added testr-args option support for tox coverage * Fixed OS::Neutron::Pool creation * Showing member list for nested resources * Update oslo db * Update olso gettextutils * Update base oslo modules * Fix order of arguments in assertEqual (patch 1/2) * "version" section should be required in template * Assign X-Auth-Url header in a separate middleware * Store credential ID for AccessKey and SignalResponder * heat_keystoneclient migrate create_ec2_keypair to v3 API * Don't delete trust on backup stack delete * Make LB-updating in rolling update more reliable * Don't pass empty security groups in port creation * add the validation of MaxSize ,MinSize and DesiredCapacity 2014.1.b2 --------- * Implement adopt-stack for nested stacks * Implement adopt-stack * Always specify preserve_ephemeral on server rebuild * Document Heat terms in glossary.rst * Fix error in RS Auto Scale properties schema * Fix adding heat_stack_user role via v3 API * Refactor heat gate testing contrib support * Ignore tox -e cover generated files * Database model for software config/deployment * Add a new ThreadGroupManager class * Make endpoint_type configurable * Fix OS::Neutron::Pool validation * Fix order of arguments in assertEqual (patch 2/2) * Remove dependencies on pep8, pyflakes and flake8 * Fix syntax error in docs * Allow choice in how SignalResponder user id is stored * Fix incorrect resource types in docs/comment/code * new method 'HeatTestCase.patchobject' * heat_keystoneclient migrate auth_token/service_catalog to v3 API * Convert heat_keystoneclient user enable/disable logic to v3 API * Convert heat_keystoneclient user-delete logic to v3 API * Convert heat_keystoneclient user-create logic to v3 API * Turn block_device_mapping.volume_size to int * Refactor MySQL long text support * Add a new "UpdateWaitConditionHandle" resource * Enable better sub-classing of common Schema class * Adding Range constraint for SIZE property * Fix ceilometer alarm properties schema * Remove heat-cli-guide * Use oslo crypto * Use region for cinder management uri * New middleware to handle SSL termination proxies * Add _() to rackspace resource strings * Added heat url in config for heat standalone mode * Let Integer property convert strings to numbers * Add stack id and resource id in logs * Update heat.conf.sample * Fix comparison with singletons * Fix asserttion of types * Fix showing events on swift * update pom.xml files with clouddocs-maven-plugin version 1.12.2 * Don't query for resource during stack creation * Using _handle_not_found_exception in resources * Implement neutron metering resources * Remove superfluous tag schema from Volume * Include a format version in generated templates * Generate provider templates with Boolean params correctly * Correct use of Fn::Split in generated provider templates * Convert Server to new Schema format * Use the new Schema class for template generation * Close SSH connections in Cloud Servers resource * Add filter and pagination to stack_get_all * Fix heat-keystone-setup error when try to create heat user * Implements Nova FloatingIP resources * Add way to group exceptions in DependencyTaskGroup * Fix unused variables 2/2: enable unused var check * Fix unused variables 1/2: add more asserts * heat_keystoneclient revise get_ec2_keypair * Store AccessKey secret_key in resource data * Update Loadbalancer default template to F20 image * Tolerate deleted trust on stack delete * Fixes duplicate calling add_constructor() * Service authorize stack user from provided stack * Add contrib to py26 and py27 gates * Fix more regressions in contrib * Avoid error on double-delete of nested stack * Enable parallel while deleting neutron resources * Add ability to configure Heat and Trove client options * Remove override of "patch" function * remove obsolete comment from rackspace clients.py * Fix schema format in template generation unit tests * Validate number of instance metadata entries * Introduce a way to trace a resource's implementation * Add policy enforcement to ReST API * Replace try...except...pass block with assertRaises * Add documentation for multi-engine * Make LoadBalancer nested stack template configurable * Improve tools/uninstall-heat * Refactor Instance#_check_active * Add migration method to test sqldump files * Test db migration 31 * I18N support for InvalidContentType exception * Fixes typo of explanation on exception.py * Fix get_column_num problem in heat-keystone-setup * Use oslo db.migration script * update rackspace clients.py * log warning, when $SERVICE_HOST is localhost * Remove usage of mox class * Sort the output of config/generator.py by group name * "mountpoint" should not be required parameter * Deleted TEMPDIR on exit * Update log message for scale out/in * Remove redundant word from OS::Nova::Server * Enhance message for watch rule * Fix regression in Rackspace Cloud Servers tests * Add test for AutoScalingGroup resize and metadata * Imported Translations from Transifex * Rename scaleout_apis.rst -> scale_deployment.rst * Use WithScenarios base class instead of load_tests * Filter resource types by support status * Do not use python built-ins as variable names * Add test coverage for SignalResponder delete * Fix SignalResponder signature response when deleted * Fix a typo in the README for docs * Empty files shouldn't contain copyright nor license * Imported Translations from Transifex * Don't provide default values to properties.get() * Added session_persistence property to VIP * Updated from global requirements * Add new Ceilometer combination alarm resource * Imported Translations from Transifex * Change loglevel for certain failures * Let users specify metadatas on swift accounts * Do not override cloud-init cloud_config_modules * Fix misused assertTrue in unit tests * Add migration test framework * Remove unnecessary setUp call * add assertion to heat-keystone-setup script * Simplify update_with_template() method * Fix copy/paste errors in API docstrings * Convert Neutron resources to new Schema format * wsgi.Resource exception handling to not log errors * SignalResponder store access/secret in resource data * SignalResponder, set resource_id in the correct place * Add sanity check to ensure user_id can be trusted * Correct create_trust_context docstring * Fix comparison with singletons * Add an external gateway property to neutron router * rackspace: Convert resources to new Schema format * Prevent tempest from failing upon ActionInProgress * Add nested resource references to resource group * Add support for rebuild --preserve-ephemeral * Don't pass swift headers as None * Convert AWS network resources to new Schema format * Use property name constants in CinderVolume * Convert [Cinder]VolumeAttachment to new Schema format * Add a schema for the AWS::EC2::Instance Volumes property * Convert Instance to new Schema format * rackspace: Convert CloudLoadBalancer to new Schema format * rackspace: Convert Scaling resources to new Schema format * EventService exception handling to not log errors * WaitCondition Count property is now updatable * Use property name constants in Ceilometer alarm * Remove useless validate methods * Add support for multiple encryption methods * Imported Translations from Transifex * oslo: add the crypto module * Improve autoscaling error message * Convert numeric values in instance metadata to strings * Add oslo mock fixture * Fix misused assertTrue in unit tests * Fix stack_get_by_name does not list nested stack issue * pep8 fix: assertEquals -> assertEqual * Change assertTrue(A in B) to assertIn(A, B) * Adds parameter_groups to HOT specification * Convert OSDBInstance to new Schema format * Convert resources to new Schema format * Convert Swift resources to new Schema format * Convert User resources to new Schema format * Convert Autoscaling resources to new Schema format * Convert Ceilometer Alarms to new Schema format * tests: Don't access properties_schema directly * Convert [Cinder]Volume to new Schema format * Enables db2 server disconnects to be handled pessimistically * Add OS::Neutron::RouterL3Agent for router.py * Deny API requests where context doesn't match path * Add validation for an existence of a resource type * Fix missing policy enforcement in CFN API * Add support for network name for os::nova::Server * Make the mountpoint property description clearer * Don't replace (and log) the same resource entry * Remove unused variable badkeys * Sync global requirements to pin sphinx to sphinx>=1.1.2,<1.2 * oslo: update the remainder of the modules * oslo: add the test module needed by test_migrations * Utilize stack-lock for multi-engine support * Implement engine listener service for multi-engine support * Implement stack-locking for multi-engine support * heat-manage man page not generated in doc build * Allow docker plugin to run w/o deps * Sync oslo threadgroup.py to fix wait & stop methods * Database changes for multi-engine support * Document Port properties * Imported Translations from Transifex * Add OS::Neutron::NetDHCPAgent for neutron/net.py * Remove unused dumps validation in JsonParam value * Remove oslo uuidutils.generate_uuid from heat code * Sync oslo rpc * Update tox.ini to use new features * Replace try...except block with assertRaises * Add load balancer PoolMember resource * Allow intrinsic functions to be called in any order * Instance call build_userdata directly * Make build_userdata user_data_format aware * Account for truncated resource names in test PhysName * Fix regression in cloud server tests * Clean up useless ex variable * Imported Translations from Transifex * Set the rpc control_exchange "again" * oslo: update the rpc module * oslo: update config generator * Use the new oslo py3kcompat.urlutils * oslo: add py3compat * oslo: delete rpc/securemessage.py * contrib: Add Docker Container plugin * Properly reconnect subscribing clients when QPID broker restarts * Call cfn-create-aws-symlinks in boothook.sh * Add REST endpoint for abandon-stack * heat engine changes for abandon-stack * Change ID column of Event table to UUID * Fix error in Trove Instance schema definition * Fix stack-show on a TemplateResource with outputs * Handle TemplateResouces with the wrong template extension * Pass the files correctly though the update mechanism * Add SupportStatus class for resources 2014.1.b1 --------- * tests: use server.test not example.com * Add collection count to stack list * Property methods for resource metadata * Openstack Trove (DBaaS) resource * Fix bad resource schema for Volume * Add attributes schema to OS::Neutron::FloatingIP * Restrict sort_keys for stack lists * Return map parsed value at JsonParam.value * Make db API respect context show_deleted * Bump to sqlalchemy-migrate 0.8.2 * Add heatclient to available clients * Provide access to Trove client * run_test.sh -V --unit doesn't run using virtualenv * Factor Schema out of properties.py for re-use * Sync DB2 error code handling from oslo * Add a .coveragerc to exclude tests and oslo * Remove unused fake test code * Remove duplicate test scenario * Remove property decorator in TemplateResource * Migrate away from rackspace_resource * Fix show_deleted errors in RequestContext * Remove owner_is_tenant from RequestContext * Remove misleading docstrings in ContextMiddleware * Derive context is_admin from policy * Fn::Replace support for type Number * VersionNegotiation - 404 if no version is provided * Make engine service docstrings conform to Sphinx * Imported Translations from Transifex * Add check_is_admin to common.policy.Enforcer * Ensure that members is a list * Catch error deleting trust on stack delete * Fix not correct AWS::StackId value * Avoid eventlet-unsafe exception handling * Let resources decide when to update * Remove external AWS links and add doc if needed * Add API endpoint to query build information * Implement PrivateIpAddress attribute * Sync openstack.common.local from oslo * Use all available headroom for autoscaling * Use ScaledResource as type for InstanceGroup members * test_common_policy cleanups * Clean up "target" interface to policy * Remove param explode_nested from doc * Add coverage for trusts parser.Stack delete path * Add test for OS::Heat::HARestarter * Improve coverage of storing credentials in parser.Stack * Fix BaseException.message DeprecationWarning * Adds ability to configure various clients used by the Heat * Define deletion policy constants * Add filter support to stack API * FaultWrapper error mapping supports parent classes * Add exact filter support to SQL API list stacks * Add a missing mock to rackspace cloud server test * Added support for Allow-Address-Pairs feature * Fix i18N compliance with non-existant keypair * Fix the middleware MIME type * Fixes bullet list without blank line issue * Doc usage enhancement * Make heat depend on python-heatclient * Remove Component class * Fix some docs errors/warnings * Add a guide to setup standalone mode * Fixes Error when contain Non-ascii in template * Add _() to fix i18N compliance (part 2) * Make instance Tags updatable * Allow nova metadata to be updated * Get pool members from DB API * Add _() to fix i18N compliance (part 1) * Implement a Heat-native resource group * Add links section to the stacks index response * Add support for limiting and sorting stacks * Don't use the last server fake, but the one we want * Ensure autoscaling actions occur for percentage adjustment * Update install.sh to reflect recent oslo.db format * Remove unused db/sqlalchemy/manage.py * Revert "Implement stack-locking for multi-engine support" * Implement Tags for S3 bucket * Add property doc strings for S3 bucket * Fix some direct imports from sqlalchemy * Move resource doc generation to doc/source/ext * Fix server update attribute test * Shorten physical resource name to custom limit * Managed Cloud compatibility for Cloud Servers * Refresh Cloud Server data for RackConnect check * Use get_secgroup_uuids in Instance * Rewrite get_secgroup_uuids to avoid resource_by_refid * Implement stack-locking for multi-engine support * Imported Translations from Transifex * Rename exception NoUniqueImageFound * Implement update for neutron port resources * Implement update for neutron router resources * Using a number in str_replace causes an exception * Refactor tests to use mock * Fix "members" property check * Imported Translations from Transifex * Add property documentation for the waitcondition * Set the waitcondition maxvalue to 12 hours as AWS specifies * Implement update for neutron subnet resources * Implement OS::Neutron::SecurityGroup * Implement update for neutron network resources * Imported Translations from Transifex * Create a guide for scaling out Heat API's * RackConnect compatibility for Cloud Servers * Check that the epel repo exists before adding it * Add a man page for heat-manage * Imported Translations from Transifex * Send usage notifications on major stack events * Rename admin flag on SqlAlchemy#stack_get * Make check_uptodate compatible with BSD shells * Add Rackspace Cloud DNS Resource * Resources for Rackspace Auto Scale * Implement volume tags as metadata * Imported Translations from Transifex * Ensure apt-get installs do not prompt user input * Add a link method to Thread * Make Fn::Select accept an integer selector again * Stop irratating pep8 error in test_clouddatabase.py * Assert that all function exceptions have the function name * Only log to console in heat-db-setup * Move all possible function tests into scenarios * Change heat-api.org to openstack.org * Add doc support for update_allowed * Instance delete should check for 'DELETED' status * Imported Translations from Transifex * use exception str() not .message * change neutron to use UpdateAllowed property schema * change alarms to use UpdateAllowed property schema * change contrib/ to use UpdateAllowed property schema * change base resources to use UpdateAllowed property schema * Support defining update_allowed in the property_schema * Fix nested stack test setUp ordering * Delete deprecated docs/ directory * Tolerate lookup failures in Fn::Select * use msg_fmt not message in Exceptions * Stub out unmocked keystone in test_engine_service * Stub out unmocked keystone auth in signal tests * Reverse assert arguments so the errors make sense * Updated from global requirements * Prove that a user can't remove global resources * Use resource_id_set to clear resource ID's * Fix sqlalchemy migrations * Fix sqlalchemy models * change assertEquals to assertEqual * Imported Translations from Transifex * Allow user_data to be passed without modification * Add rebuild to OS::Nova::Server * Refactor Nova server resizing to be self contained * Repeat Ceilometer alarm actions by default * Allow plugins to be specified as a cloud_backend * Updated from global requirements * Imported Translations from Transifex * Document route table properties * RS LoadBalancer should return its ID as Ref * Document subnet properties * Document vpc properties * End doc sentences in a consistent way * Document security group properties * Document network interface properties * Add support to disable resources * Move db_sync into the sqlalchemy DB api * Correct misleading template guide Ref example * Add granularity option to purge_deleted * Imported Translations from Transifex * Updated from global requirements * Add a test for TimeoutInMinutes accepting a str int * Catch all yaml exceptions * Make the template and env yaml parsing more consistent * Updated from global requirements * Fix incorrect indentations found by Pep 1.4.6+ * Prevent urlfetch from returning encoded chars * Use "python -m coverage" instead of coverage cli * Stop using openstack.common.exception * Update openstack.common.db * Imported Translations from Transifex * Convert str passed as Numbers/Integer to numbers * Wrap engine exceptions in _() * Wrap common exceptions in _() * Wrap api exceptions in _() * Allow RS LoadBalancer resource to have no nodes * Updated from global requirements * Add requests library to requirements.txt * Provide more tests for DB APIs * Make Autoscaling update policy tests faster * Remove spurious traceback in test * Remove a buggy method in sqlalchemy.api * Imported Translations from Transifex * Updates OpenStack Style Commandments link * Imported Translations from Transifex * Don't allow updates when another action is in-progress * Do not attempt a stack update when it is suspended * Implement native Nova keypair resource * Allow flavor and image names in CS resource * Ignore H803 from Hacking * Enable exception format checking when testing * Validate template parameter attributes * Fix regression in DBaaS tests * Revert "Don't install EPEL rpm on CentOS 6.4" * Imported Translations from Transifex * Allow DependsOn to accept a list * Add property port_id to RouterInterface * Add log_handler to implement the publish_errors config option * Add keystone_authtoken section into the heat.conf.sample * Pass errors from *_format.parse() to the caller * Imported Translations from Transifex * Raise error if instances are created with names > 63 chars * Fix heat deletion failed if floating ip is not found * Imported Translations from Transifex * Allow overriding the instance_user per server * Return Integer or Float casted value in NumberParam * Move check_uptodate.sh into config/ and delete tools/conf * Start using tools/config instead of tools/conf * update the config generator from oslo * Updated from global requirements * Fix some docs warnings and errors * Remove obsolete redhat-eventlet.patch * Add cinder prop image, deprecate imageRef * DB API : tolerate None values to _encrypt * Fix RequestContext.to_dict user/username inconsistency * A resource to generate random strings * Fix possible race issue with test_engine_service * Begin 3 chapters for Orch API Ref Manual * Migrate to Oslo DB 96d1f887dda Part 3 * Update openstack.common.policy from oslo * Make templateResource not replace on update * Fix the signal details string * Rolling update support for Instance/AutoScalingGroup * Fail stack-create if script exits with non-zero status * Add help for purge_deleted command age argument * Catch the appropriate exception for missing instance * Don't install EPEL rpm on CentOS 6.4 * Increase support for the AllocationId property * Save parse errors in TemplateResource for later * Create a better exception in Fn::Replace * Update some cases of iterating stack resources * Don't try validate TemplateResource properties in template_validate * Cleanup nested loop variables in TemplateResource * Fix clashing loop variables in TemplateResource * Move the registration of the global env to after plugin resources * Make the testing of resource loading easier * allow "members" property to be absent * It is necessary to update pool_id for Neutron LB * Update resource stacks automatically * Implement parser.Stack.__delitem__() * Don't iterate over Stack.resources dictionary * Get InstanceGroup InstanceList from get_instances() * Refactor total_resources * Make parser.Stack a proper Mapping * Unit tests: don't use status strings from class * Don't obtain resources through stack.resources * Add contrib to tox pep8 check * Handle NetworkNotFoundClient and PortNotFoundClient * resource_data saved unencrypted * Change pyrax identity_type of Rackspace resources * Enabled request_id in RequestContext * Make sure that nested stacks have their watch rules checked * Start the watcher task if a nested stack has watches * Add a new db api stack_get_all_by_owner_id 2013.2.rc1 ---------- * Add some docs on how to setup Ceilometer to use Alarms * resource_id check on router gateway, interface delete * Handle BadRequest in VolumeDetachTask * HOT str_replace default to empty string for param * Open Icehouse development * Fix F17 CFN link in Getting Started * Imported Translations from Transifex * Add the "show" attribute to the neurton attribute_schema * Add _() around the attributes_schema in net.py * heat_keystoneclient: Fix consuming trusts via v2 API * Disable lazy translation * Updated from global requirements * Validate template size during download * Log exception traces in APIs * Purge ubuntu getting started guide of old info * Purge Fedora getting started of old info * Remove tools/openstack* * Fix inconsitencies in HOT template guide and spec * Lazily load resources when loading a Stack * Do not assume fixed_ips is a specified property * api : default signal body to None * Store tenant with trust details in user_creds * Conform stack resource error so it gives a 4xx * Imported Translations from Transifex * Return parsed list value in CommaDelimitedList * Make availability zone for CinderVolume optional * Document neutron Net properties * Provide config option to cap events per stack * Handle HOT param constraints in provider templates * Do not translate HOT param constraints * Add attributes_schema to CinderVolume * Make HOT parser errors translatable * Document floatingip properties * Rename counter_name to meter_name in alarm * Add config option to limit max stacks per tenant * Document EIP resource properties: * Skip None values in fixed_ips when creating Port * Remove Neutron VPN resources id attributes * Remove Subnet id attribute * Remove Router resource id attribute * Remove Port resource id attribute * Remove Neutron firewall resources id attributes * Remove Neutron load balancer resources id attributes * Remove Net resource id attribute * Remove CinderVolume id attribute * api ec2token: allow auth_uri conf to be set via keystone_authtoken * api ec2token: Clear failure when no auth_uri specified * Imported Translations from Transifex * Add method to count events by stack * Comparing device name values instead of their reference * For Subnet gateway_ip, pass None for empty string * Sync gettextutils from oslo * Require oslo.config 1.2.0 final * Move Rackspace resources into contrib * Improve test coverage of stack deletion * Stop nested stack updates exceeding resource limit * Use name property in OS::Nova::Server if set * Format error on urlfetch.get fail * StackResource set requires_deferred_auth=True * Replace first_public_address/first_private_address * HOT str_replace to use string.replace, not string.Template * Document internet gateway properties: * Consider downloading a valid status for CinderVolume * Add the shared property to neutron Net * Add tenant_id property to neutron Net and Subnet * Allow resource_by_refid returning resumed resources * Allow access to attributes of resumed resources * Stop stack updates from exceeding resource limit * Tolerate bad environment until validation * Limit resources per stack in nested stacks * Provide config option to limit resources per stack * Replace OpenStack LLC with OpenStack Foundation * Document neutron health monitor and pool properties * Use unicode() when serializing REST API errors * Document swift properties and attributes * assert_ is deprecated, use assertEqual * Document aws loadbalancer properties * Nested stack derive requires_deferred_auth from resources * Mark reservation_id, config_drive as implemented * Sync gettextutils from oslo * make get_flavor_id to work if input is flavor id * Add 'repeat_actions' property for OS::Ceilometer::Alarm * Document nested stack properties * Document user properties * Use built-in print() instead of print statement * Document instance resource properties * Document autoscaling resource properties * Remove broken tripleo links from on_devstack doc * Encode values as utf-8 before encrypting * Document neutron vpn service properties * Fix misused assertTrue in unit tests * Document aws cloud watch alarm properties * Document ceilometer alarm properties * assertEquals is deprecated, use assertEqual * Docs for building heat-cfntools images with diskimage-builder * Consistent logging in the API to better log exceptions * Use the generic RequestLimitExceeded exception when possible * Validate OS::Nova::Server block_device_mapping property * Use strings for block device mapping info * Add methods to help calculate a stack's resources * Add error handling to property value resolution * Migrate remaining TEXT columns to LONGTEXT * Document volume properties * Add security_groups for create_port() * Impose a size limit on JSON request body * Add HOT functions to dependency checks * Use physical_resource_name as Ref for Instance/AS Group * Make some heat resolve functions workable in hot * Enclose command args in with_venv.sh * Pass debug mode to eventlet.wsgi.server * Only send traceback to users when in debug mode * Change the dbinstance to F19 * Move dbinstance into a TemplateResource * Make global TemplateResources usable in the tests * Make the new template validation usable from tests * Add DB API to get the count of stacks per tenant * Set a small max_template_size for test_long_yaml * Only validate credentials on create based on resources * Run cfg.CONF.reset() on test cleanup * Fix H233 in sphinx config * Fix TemplateResource list property conversion 2013.2.b3 --------- * parallelize StackResource delete * Adding IPsec site connection to Heat resources * Adding IPsec policy to Heat resources * Adding IKE policy to Heat resources * Adding VPN Service to Heat resources * update neutronclient to 2.3.0 minimum version * parallelize instance delete * parallelize volume deletion * Implement parallel delete * Fix AttributeError exception in autoscaling * Update nested stacks in parallel * Fix problem with mocking tasks * Create a Stack.update_task() method * Change _testnoexisthost_ references in tests * Migrate stored credentials to keystone trusts * Remove py33 from tox.ini until eventlet is ported * Make error message for InvalidTemplateReference sane * Add unit tests for Resource dependency inference * Remove some heat-cfnclients only exceptions * Add trust_id and trustor_user_id Context and DB * Allowing to pass network name to router gateway * Don't use a query for watch_rule_get() * Don't use a query for stack_get() * Delete the old example config files * Remove references to the multiple config files * Support ISO8601 duration format for UpdatePolicy PauseTime * Sync rpc from oslo-incubator * Make security groups associated with Neutron port work * Parallelise Server updates * Rackspace: Parallelise CloudServer updates * Parallelise Instance updates * Allow resources to be updated in parallel * Don't stub LoadBalancer.update in autoscaling tests * Do updates based on a single dependency list * autoscaling test fix assertRaises Exception warning * Remove localhost references from tests * Implement native nova server resource * Generate docs using new properties Schema class * Give Property constraints a string representation * Fix CFN API error responses * Remove aws_creds from DB API * TemplateResources need to download from local "file://" urls * Add support for local file urls * Provide user control for maximum nesting depth * Cleanup the Properties doc strings * Add auto code api doc generation * Implement interruption-free update and rollback * Remove unnecessary aws_* from user_creds * Remove unused service_* columns from user_creds * Change localhost references in test_nested_stack * Add schema for security group rule * Don't delete failed instances in InstanceGroup * Add VPCZoneIdentifier attribute for autoscaling * Make logical_resource_id renaming backward compatible * Add the missing heat.po files into heat * Add the api config opts in groups to deal with the single heat.conf * Rename OS::Metering::Alarm to OS::Ceilometer::Alarm * Catch a NotFound exception in signal_responder delete * Improve error message for nova unknown status * Remove backup resources on stack delete * Add a DB API to swap two resources between stacks * Add a "rollback" parameter to StackUpdate * Always resolve properties against the current stack * Remove the rest references to exception.py * Support native naming in InstanceGroup * Include Description in conversion from legacy Property schema * Add support for source security groups * Adds support for Neutron Firewall * Autoload Nova extensions * Allow in-place update of nested stack * Enhance StackResource update for more use cases * Store the backup stack during updates * Pass owner_id to stack_get_by_name() * Add a method of creating a backup stack in the DB * Evaluate lazy translation in exception __str__ * Allow a Provider with a known facade its own schema * Use the global environment to map Quantum to Neutron * Add a has_interface() method to the resource class * Only create user_creds row on initial stack store * remove unused config options * Pass token as a callable to Ceilometer client * Implement a load balancer resource using new neutron pool * Use oslo.sphinx for the doc templates * Rename event logical_resource_id to resource_name * Use string constants to prevent typo errors * Add a CloudWatch::Alarm implementation based on Ceilometer * To support both CW and CM, return alarmurl from policy ref * Store the generated signed urls in resource_data * Remove "lazy=joined" from the resource_data backref * Try to reduce the number of tests with the same stack_id * Implement Fn::MemberListToMap * Fix the main docs index page * Remove the usecases from environment.py as they are in the docs * Add some basic evironment docs * Do not delete nova server on create fail * Do not assume nova provides a fault on ERROR * Add a script show all possible state transitions * Limit maximum size of all templates * Make the API for getting dependency graph edges public * Pass the previous stack to StackUpdate * Improve update debugging messages * Fix all the sphinx-build warnings * Fix some flake8 warnings in doc/resources.py * Fix crash in "make html" introduced by the global env * EC2token middleware implement multi-cloud auth * Replace httplib with requests for ec2tokens auth * Always validate auth_uri with allowed_auth_uris * Add UpdatePolicy attribute to Instance/AutoScalingGroup * Use the global environment to define AWS::CloudWatch::Alarm * Load deployer/global environment files at startup * Add an environment_format.py like the template one * Process request exceptions while fetching template * Add new attributes to EIPAssociation resource * Remove the Property.schema_from_param() method * Generate property Schema objects directly from parameters * Use Template to instantiate TemplateResource * Handling re-delete in rackspace db resource * Fix incorrect use of ServerError * Introduce nova_utils.server_to_ipaddress * Convert heat.common.template_format to use C yaml * Use system locale when Accept-Language header is not provided * Use LONGTEXT for templates in MySQL * Wrap the resource registration in a global environment * Create a Schema from a parameter * Allow Parameters to set defaults for TemplateResource * Fix install.sh calling setup.py * Allow Description in properties schema * Use nova_utils for keypair validation * Move _check_resize to nova_utils * Move _deferred_server_statuses to nova_utils * Move _delete_server to nova_utils * Revert "Implement an "Action in progress" error." * Add code from Oslo DB 96d1f887dda Part 2 * Make Event object independent of resource object * Translate user-facing exception messages * Updated LaunchConfig for AutoScaling UpdatePolicy * Catch "FloatingIpPoolNotFound" in eip.py * Tests for s3 and swift resources were extended * Store owner_id on Stack so updates maintain it * Derive keystone_ec2_uri from auth_uri * Extract failure reason before deleting nova server * Update test requirements * Handle heat with SQLAlchemy >= 0.8 * Tolerate missing user on signal responder delete * Fixes files with wrong bitmode * Fix syntax description of HOT get_attr function * Differentiate resource types in test_update_rollback_remove * Stub ResourceWithProps instead of GenericResource * Hot SoftwareConfig model part * Update Oslo to 96d1f887dda Part 1 * Move property constraints validation to Schema * Remove unneccessary Property constraints from unit tests * Add constraint checking to Property schema * Tidy up a few places in test_engine_serivce.py * Adding HOT str_replace and get_resource functions * Revert "Add missing _ imports to allow doc generation" * Move heat-cfn, heat-boto, heat-watch to new repo * Add debug option to run_tests.sh * Introduce new resource_data_delete db api * Not to eat Metadata parsing error * Fix intermittent failure in autoscaling tests * Use correct actions for StackResource * Resolve LaunchConfig references * Get rid of unused greenlet things in test_resource * Fail fast if Resource action methods are missing * Don't raise ResourceFailure directly in Instance * ReST API: Add an API for retrieving resource schemata * RPC: Add an RPC call to get a resource type schema * RPC Client: Add missing unit tests * Port policy from oslo and refactor heat policy * Enable multi-cloud standalone mode * Fix problem creating ResourceFailure * Do validation in parameter schema * Validate created/updated stacks in StackResource * Tidy up RPC API definitions * Define a Schema format for properties * Remove meaningless property set in models.HeatBase * Tolerance for modified ceilometer alarm notification * Initial input for HOT template guide and spec * Remove unnecessary individual import tests.utils.X * Ensure all REST API error responses are consistent * Remove raw_template_get_all from db api * Provide a way to clean up soft deleted data * Enable stack soft delete for event persistence * Implement neutron pool resource * Implement neutron health monitor resource * db: Remove deprecated assert_unicode attribute * Refactor some tests for stack soft-delete * Add unittests for faultwrap middleware * Use openstack rpc functions to generate _Remote exceptions * Exclude heat-cfn, heat-watch from pep8 * Fix H231 Python 3.x incompatible 'except x,y:' * Fix H501 Do not use locals() for string formatting * Provide a way to clean up testing database * Add missing _ imports to allow doc generation * Refactor compute resources to use nova_utils * Updated from global requirements * Implement an "Action in progress" error * Don't cache data from the API that could change * Stop copying UUIDStub, put it into tests.utils * HOT parameter validator part * Fix test cases pass dict schema directly as parameter schema object * Rename Quantum to Neutron * Add the enabled property to the ceilometer alarm * Refactor useful nova functions for re-use * Refactor InstanceGroup to use a nested stack * DB models and migration scripts for soft delete * Returns text error when instance validation fails * Add Babel missing requirement * Fix test cases pass dict as template object directly * Don't assign "error" variable twice * Change token name from context * Revert "Replace part_handler.py with write-files cloudinit mechanism" * Rename: VALUES to ALLOWED_VALUES, PATTERN to ALLOWED_PATTERN * Remove support for eventlet 0.9.16 * Small tweaks to recreation of remote errors * Enable localizable REST API responses via the Accept-Language header * Include the resource and action in ResourceFailure exceptions * Unit tests: Don't raise ResourceFailure directly * unit tests: Add a handle_delete method to GenericResource * Rackspace: Don't raise ResourceFailure exceptions * Sync gettextutils from oslo * Resource: Clean up exception handling and error messages * Add help option to Config Settings * Rename rackspace server ImageName, Flavor, UserData * Call cfn-create-aws-symlinks in rackspace servers * Stop delete polling after status == DELETED * Make Volumes work with the default AvailabilityZone * Allow the Ceilometer Alarm to be used with cfn-push-stats * Add the AutoScalingGroupName to the server Tags * Don't use a static uuid for the stack_id in ceilometer_alarm * Remove password auth from pyrax * Move the random_name() function from loadbalancer to utils * Clean up the attributes module * Use dummy_context() for rackspace server test * Assign rackspace server name from physical_resource_name * Replace rackspace PublicKey property with key_name * Tolerate an actual boolean for NoEcho * Replace part_handler.py with write-files cloudinit mechanism * Rackspace database resource output is null * Fix for bad content inside Resources element * Initialize resources to DELETE-COMPLETE if missing during stack delete * Rackspace database resource output is null * Clarify text in heat/tests/templates/README * Use subsections in resource doc generation * Functions documentation cleanup * Print before exiting * Add Cloud Server support for RHEL and CentOS * Support any distribution without UserData/MetaData * Allow template resource use outside of Environment * Add rest endpoints for resource template generation * Add a Ceilometer alarm resource * Fix a timing sensive cloudwatch testcase * Auto-document all resource types * Sphinx extension to generate resource documentation * Enable service validate-template for hot template * Skip RSA generation during tests * Always convert AllowedValues to a list * Add some docs for intrinsic functions * Fix cloud_watch delete when the watchrule is not found * Teach ScalingPolicy and Restarter to create signed urls * Make the current alarms use the signal action * Add an API for passing a signal through to a resource * Generate a template from a resource implementation * remove remote_error and corresponding try...catches * Replace urllib2 with requests in urlfetch module * HOT parameter validation model translation * make heat-api return a parsable error * Fix loguserdata output to file issue * Use new style classes * Add resource for Rackspace Cloud Servers * api : Implement OnFailure option to cfn API CreateStack call * Add `default` attribute in hot parameter definition * Refactor the code in heat/tests/test_volume.py * Handle 'detaching' state of Volume * Reset state before resource recreation * Only use a token for openstack client operations * Migrate all tests to use dummy_context * Add missing Aapche 2.0 license headers (H102) * Add a py33 tox environment * Reset the the watch_rule.last_evaluated on start up * Only create the period watch task if there is a watch in the stack * Wrap the watch rule start in a method * Configure standalone pipelines for cfn and cloudwatch * Set role headers from ec2 authentication * Set tenant headers from ec2 authentication * Update openstack.common.config * Handle InstanceType change in Instance.handle_update * Move url_for into heat_keystoneclient * Test utils dummy_context for tests that need one * Put pre-created resources in state INIT COMPLETE * add docs from the heat wiki 2013.2.b2 --------- * Add a test for customizing AWS::EC2::Instance * Add tests for resource-data delete bug * Fix resource-data delete bug * Fix version and location of heat doc build * Check missing parameters during stack create * Don't reload haproxy and use ensureRunning=true * Make sure that Tags on the InstanceGroup get passed to nova * Test that Tags get converted into nova metadata * Align OpenStack client versions with project requirements * Cleanup and make HACKING.rst DRYer * engine : Allow loadbalancer resource to work with no key * Create implicit depends from gateway to public subnet * Wait until quantum resources are deleted * Do not override FnGetAtt * Add resource_data table for free-form key/value data * provide test for nested stack error path * Add Rackspace cloud loadbalancer resource * Update oslo.notifier and always register options * avoid excessive database calls while loading events * Global disable scheduler _sleep instead of mocking * Rename part-handler.py to part_handler.py so it can be imported * Handle conversion of MAP properties to JSON params * Tolerate an empty environment properties * Add length validation to properties of type LIST and MAP * Use new environment and parameters on stack update * Define behaviour for properties with None values * Let git ignore pydev project description files * Suggest the use of tripelO images * Make the waitcondition signed url more generic * Check duplicate names between params and resources * engine : add suspend/resume support to User resource * engine : add suspend/resume support to watch resource * Sync install_venv_common from oslo * Stop patching the GenericResource's property_schema * Enforce credentials requirement on stack create/update * cleanup watchrule delete logic/tests * Fix command name display issue in heat-manage usage * engine : autoscaling pass instance id's not names to loadbalancer * Rackspace cloud database resource provider * add missing gettextutils imports * engine : perform periodic tasks with stored stack_context * implement stack metadata * Rework associations from vpc to quantum resources * Tolerate 404 on user delete * Get rid of template caching in resources * Explicitly pass old json snippet to update * tests : remove duplicate suspend tests * Add resume support to InstanceGroup * engine : resume support for nested stacks * api : Add actions resume support * Add resume support to Instance * Add initial resume logic to engine * destroy failed instances created by auto scaling * Expose resource dependency required_by to REST API * install "_" via gettextutils * engine : simplify resource state check * engine : remove unnecessary default check_*_complete functions * Fixup handle_create backup restore * Remove comments from requirements.txt (workaround pbr bug) * add GET /{tenant_id}/stacks/detail to Heat API * Add suspend support to InstanceGroup * Fixup assert_has_keys * autoscaling : Fix issue when scaling to zero instances * Add editor backup files to .gitignore * Ports depend on the subnets in the same network * Add dependency between RouterGateway and RouterInterface * Add MinLength, MaxLength to properties schema * engine : autoscaling refactor Instance list->object logic * api : Add ReST actions POST method * engine : parser.Stack create general stack_task * engine : suspend support for nested stacks * Add suspend support to Instance * engine : stack_resource change state_description to status_reason * Raise suitable exception when stack validation fails * Handle YAML parser error as well * Changes for HOT hello world template processing * OS::Quantum::Subnet resource, add enable_dhcp * check content type in JSONRequestDeserializer * Store created nova client in OpenStackClients * Allow JSON values for parameters * Add initial suspend logic to engine * Use print_function compatible syntax * Allow a resource delete to be re-attempted * Emit alarm actions if a rule remains in ALARM state * Initial provider templates * Fixup some trivial license header mismatches * Adding common base class for Rackspace Resource providers * Pass before and after snippets to template diff * Cache snippets in StackUpdate * Simplify a stack update unit test * Refactor and partly parallelise stack update code * make stack creation return json response * Give alarm a physical_resource_name which need no id * Do not refresh timestamp from database on read * Unrestricted username length causing error * Add VerifyAll to test methods using mox * Fix BaseException.message DeprecationWarning * Fix one of the last stack.state's -> status * Revert "check content type in JSONRequestDeserializer" * Fix and enable H303 and F403 No wildcard (*) import * Implement attribute schema for resources * Introduce a schema for attributes * Restore babel setup config options * Convert Stack to separate action/status * Updated common module from oslo * Initial provider template uploading * check content type in JSONRequestDeserializer * Detect failed instance creation in autoscaling * Support cloud-specific suffixes to server status * autoscaling fix LoadBalancer reload static resolve * Return None for physical resource name during validation * Standardise resource names in Invalid Attribute errors * suppress and log API internal exceptions * Add a Fn::Split function to aid provider templates * Add dependency between FloatingIP and RouterGateway * Add InstanceId property to EIP resource * scheduler: Simplify DependencyTaskGroup interface * scheduler: Improve task descriptions in debug logs * Cleanup the doc strings in heat/rpc/client.py * API support for Environments * Make template_format.parse usable by environments * Use PhysName for testing Swift container names * Fix bizarre Swift DeletionPolicy unit tests * Use physical_resource_name() for Swift containers * Remove unused parameter.user_parameters() * Use the Environment from within the engine * Use physical resource names with a short_id * Initial Environment class and test * engine : abstract state-transition logic * Convert Resource to separate action/status * Store stacks in the database when running unit tests * Unit tests: Create User for testing AccessKey * Unit tests: Don't use mox to stub uuid.uuid4() * Make resource ids UUIDs in the database * Convert Events to separate action/status * allow using image uuid for instance resource * fix an CFN API and AWS error mapping * Remove unused python-memcached from requirements * Use Python 3.x compatible except construct * Add bin/heat-manage to flake8 checks * Gate on H703 * scheduler: Fix an issue with wrappertasks and exceptions * Fix H702 errors and enable them * Remove explicit distribute depend * Key error when auth in standalone mode * engine : remove GreenletExit workaround * Add descriptions of the pep8 checks * Fix various Sphinx errors/warnings * Use Python 3.x compatible octal literals * Adds possible topdir to python search path * Return empty string when Fn::Select target is None * Add Fn::Replace template function * Initial mariadb support * raise an UnknownUserParameter exception when receiving an unknown param * Enable H403 * get rid of no-op __init__ methods * Rename functions which should not be run as tests * flake8 F812 list comprehension redefines fix * Only call FnGetAtt if resource is in acceptable state * Make Fn::GetAtt add a dependency * Use - instead of . for physical_resource_name delim * Make autoscale not dependent on loadbalancer impl * Use a physical name matching class in unit tests * Add Fn::Select template function * Fix instance creation when a network with no subnet is used * For Fn::Join, replace None items with an empty string * Relax lxml version requirements * tests : fix cut/paste test name shadowing * a minor fix to volume.py * Fix Hacking H304 Warnings * Fix an intermitting failure in test_metadata_refresh * Log at DEBUG level in unit tests * scheduler: Fix inifinite loop for no-wait tasks * Handle metadata updates during stack creation * Create nested stacks in parallel * Create stacks with a co-routine * Implement timeouts for nested stacks * Allow stacks to be created without a timeout * add error flow tests for volume detach * Clarify a comment which says we require KeyName - which is incorrect * Add CONTRIBUTING.rst file * Clean up DB migrations when running unit tests 2013.2.b1 --------- * Get rid of extra delays in unit tests * Restore heat.db.sync and add Deprecated message * Use heat-engine.conf for heat-manage config * Create resources in parallel where possible * Add a dependency-aware task group * Move deletion from dependency graph to __delitem__ * Make the mutable dependency graph a separate class * Make dependency graph node class public * Fix the handling of non-existing paste file * refactor test_engine_service.py * Fail validation when security groups and interfaces conflict * Add a basic heat-manage * Remove eventlet dependency from unit tests * Use a task to delete Instances * Bring in oslo.cliutils for heat-manage * Update the oslo code before importing a new module * Migrate test base class to testtools * Add CONTRIBUTING file * Migrate to pbr * Implement SecurityGroupIds property for instances * Use UUIDs for Quantum security groups * Make IDs for resources unique to ensure tests pass * Change SecurityGroups to be passed directly to nova * Add a separate Template class for the HOT format * Detach Volumes from an Instance in parallel * Handle instance volume attachments with co-routines * Add a convenience method to get instance volumes * engine : move update_template_diff functions into Resource * Instance resource remove unreachable/redundant Metadata update check * heat tests : add coverage for instance UpdateReplace * engine : replace UPDATE_REPLACE with ResourceReplace exception * Move VolumeAttachment polling to check_create_complete() * Make volume detachment a co-routine * Make volume attachment a co-routine * Verify function calls in cinder_fn_getatt unit test * Stub out sleeps in quantum unit tests * Remove unrelated tracebacks from test output * Rename requires files to standard names * engine : Fix ResourceFailure exception issues * Fix PEP H101 (Use TODO(NAME)) * update on_devstack doc * Implement OS::Cinder::VolumeAttachment * Fix PEP H902 (Use the 'not in' operator) * UpdateStack for AWS::AutoScaling::ScalingPolicy * Fix PEP H301 (one import per line) * Fix PEP H402 "one line docstring needs punctuation." * PEP: be explicit about what errors are ignored * engine : remove unused update states/status * engine : cleanup Resource.update error paths * Adds sudo check for privileged operations * The oslo module called utils is no more * Exclude build/ from flake8 checks * Tests for Router, RouterInterface, RouterGateway * Tolerate resource lookup errors for quantum FnGetAtt * Implement check_active for quantum net, port, router * The utils module in oslo is no more * Migrate to flake8 * Clean up a pyflakes error in a comment * Align usage of test skipping * Fix error in Dependencies representation * Fix SecurityGroups for AWS::AutoScaling::LaunchConfiguration * Initialise resources when service is created * Use mox for mocking quantum client test calls * Cleaned up some simple hacking/pyflakes errors * Clean up import of cinderclient exceptions * Make Volume snapshot a task * Move Volume polling to check_create_complete() * Handle errors in Volume creation * Rename handle_snapshot and pass state * use skipIf for all quantum test skip checks * Clean up VPC unit tests * Adds dns_nameserver to OS::Quantum::Subnet * Use python logging for loguserdata.py, log to console * Implement CinderVolume.FnGetAtt * Implement OS::Cinder::Volume * Copy the RHEL6 eventlet workaround from Oslo * Update install_venv_common from oslo-incubator * Use hostname from env in heat-keystone-setup * Move WaitCondition polling to check_create_complete() * Add a timeout option to the scheduler * engine : rename check_active to make it more generic * api : Fix template-show partial URL redirect * Provide example config option for instance_user * Add new exception for invalid template ref * Implement the SubnetId property in the Instance resource * heat-cfn : Make error with missing auth details more obvious * Fix GroupSet assignment to use resource id instead of name * Fix unit test coverage issues for wrappertask * Explicitely register options to fix intermittent failure * Skip more tests that require Cinder backups * templates : remove in-tree templates * tests : convert test_template_format to test-local templates * tests : convert most remaining tests to inline templates * Fix skips done in the test suite by using testtools skipIf * Wait for any nova server status that makes sense * Add test to handle nova BUILD status on create * tools : remove fetch-cloudformation-examples * docs : update local template references to heat-templates url * tests : utils parse stack specify tenant in context * tests : utils parse_stack allow stack_id override * Use scheduler for driving autoscaling task * Use a PollingTaskGroup to simplify autoscaling * Add a wrappertask decorator * Add a PollingTaskGroup task * Deprecate tools/nova_create_flavors.sh * Support password authentication * Support SnapshotId in volume creation * Give each cli its own test * heat tests : separate Autoscaling and CW alarm tests * heat tests : convert most tests to inline templates * heat tests : add parse_stack function to test utils * Fix error reporting in @stack_delete_after unit tests * Set Stack id to None when deleted * Support Snapshot policy in volumes * Allow non-replacement updates of Alarms * Sometimes use quantum for SecurityGroup * Depend on discover to fix python2.6 tests * heat api: ec2token remove unnecessary jsonutils retry * Make DeletionPolicy a resource attribute instead of a property * Use install_venv_common from oslo * Split the module lines in openstack-common.conf * Refactor instance tests to share common code * Fix test_validate to run by itself * Fix test_dbinstance not running by itself * heat tests : run_tests.sh reinstate text coverage report * Remove all references to nose * heat api : Update ec2token middleware for v4 signatures * Remove unused jenkins arguments from tox.ini * Enhance testcase for failed resource deletion * Retrieve the list of availability zones from nova in Fn::GetAZs * Fix "No handlers could be found" warnings * Fix warning about using os.tempnam in test suite * Remove unused skip_unless and skip_test decorators * Remove unused and outdated heat/testing dir * Re-work run_tests.sh to call testr instead of nose * Remove broken --doctest call from run_pep8.sh * Remove use of nose attrib plugin and most unittest * Removing all prints and capturing logging * Remove functional tests in preferece for tempest * Remove examples and update testing-overview.txt * Use testr for running gate tests * Enable running tests via testr * Make Resource.create() a co-routine * heat docs: deprecate old GettingStarted guide * heat docs : Update jeos building documentation * heat api: fix ec2token authentication * Remove pyflakes_bypass * Fix DB sync script * Update tools/integration.sh script to new docs tree * Validate properties against the schema in validate_template * heat engine : register options before using them * Add a scheduler module * Remove engine_topic configuration option * Send RPCs to 'engine' topic not 'engine.$host' * Do not initialize anything during import phase * Consolidated api-paste.ini file * Move ec2token defaults from paste.ini to .conf * Optionally allow ec2token config to come from .conf * Propagate deletion errors with exceptions * Mock delete_network in Quantum unit tests * Mark resources as failed when creation aborted * Propagate creation errors with exceptions * Assert on Resource double-create() * Fix issues with EIP unit test * Get rid of create state in Instance * Remove service _user, _password, _tenant from context * Move heat-api auth_token conf from paste.ini * Subclass keystone middleware to set headers * Improve Python 3.x compatibility * Fix pyflakes-bypass for PyFlakes 0.7 * Simplify rpc client calls * Fix the exception message in stack_resource.get_output() * Updated OpenShift template * heat-cfn: Handle parameters with = in them * uses os.urandom instead of Crypto.Random for backward compatibility * Update the README to point to docs.openstack.org/developer/heat * Clean up metadata refresh unit test * Get rid of create state in Autoscaling * Pass data from handle_create() to check_active() * heat templates : Update Wordpress config for F18 guests * heat : Getting started updates for grizzly * heat : cloudwatch paste.ini credentials incorrect * heat tools : openstack script fixes for grizzly * Update to the latest loopingcall from oslo * Remove paste config for non-existant cache filters * Remove unused and deprecated auth-context filter * Attempt to delete resources even if they failed * Fix AccessKey deletion with bad credentials * Delete unused ContextMiddleware * Replace deprecated commands with current equivalents * Fix sphinx warnings * ReST API: Translate the documentation to WADL * Add Getting Started Guides the developer doc's * No longer pass no_cache=True to novaclient create * Log tracepath for stack validate exceptions * Pass in endpoint url for quantum auth_token auth * Allow nova operations with only auth_token * Pass in endpoint url for swift auth_token auth * Allow cinder operations with only auth_token * Catch NotFound exceptions on Volume handle_delete * heat engine : Autoscaling reload Loadbalancer correctly * Don't assume a Parameter value is a str * Make swift FnGetAtt fault tolerant and block less * heat : remove fallback ec2signer implementation * Fix swift client token authentication * validate_template returns whole Parameters snippet * heat getting started : fix heat-jeos URL * Change executable file permission for rpmlint * Change executable file permissions for rpmlint * Tolerate missing keys in reformat_dict_keys * Get rid of versioninfo cruft * Bump Heat version to 2013.2 2013.1.rc1 ---------- * Create a wsgi factory method for Debug filter * If a stack create fails, ensure the stack is deleteable * Add a manual page for heat-db-setup * Add heat-keystone-setup man page * Sort the manual page list in conf.py * Allow per-deployment configuration of user id * Remove ssh from cloud-config-files * loguserdata: handle exceptions from running the userdata * loguserdata: prevent shadowing of arguments and globals * part-handler: add missing import * heat engine : fix exception syntax issue * heat docs : Add manpage for heat-boto * Remove Nova dependencies from hacking test * heat docs : Add 2013 to the copyright string * heat docs : Add heat-watch manpage * Update dependency versions to match oslo-incubator * Fix security groups (need to be accessed as attributes) * Remove todolist from docs index * Only split roles if they are not None * Revert NestedStack FnGetRefId changes * Switch to final 1.1.0 oslo.config release * heat templates : Update for F18 * heat engine : Add validation of stack names * Pin SQLAlchemy to 0.7.x * Squash Grizzly database migrations * Use internal DB management * Register DB options independently of engine * Avoid manipulating DB directly in unit test * Establish an initial version of the database * Set correct type for owner_id in DB model * heat clients : Fix --timeout option for heat-boto * Skip quantum unit tests if client not installed * Delay calling _get_user() until AccessKey is created * Recognise arn: for REST stack lookup * Update to Quantum Client 2.2.0 * heat engine : store stack on failed update * Add Quantum floating ip assoc tests to improve coverage * Add Quantum port tests to improve coverage * Add Quantum floating ip tests to improve coverage * Add tests to validate REST path to action mapping * Use stack.resource_by_refid to get the user resource * Use quantum IDs for VPC, Subnet, RouteTable resources * heat common : quieten policy logging * heat common : policy.py change LOG to logger * heat common : BaseClient respect host argument * heat clients : make --host option error for heat-boto * heat tests : Improve resource.py test coverage * heat engine : allow Properties validation failure events * heat tests : move GenericResource into tests directory * Convenience method to look up resource by FnGetRefId * fakes: remove some duplicate methods * Switch to oslo.config * Allow REST stack lookup by ARN * heat engine : watchrule quietly discard unused metric data * Use built-in exception filtering for GreenletExit * heat engine : Loadbalancer template watch reference should be Ref * make parsed template snapshots before updating * heat engine : Ensure properties validation is caught * Allow instance NetworkInterfaces to be list of str or dict * Test coverage for NestedStack, and fix FnGetRefId * When updating the metadata load the stack with the stored context * add missing licence header * Stop heat services from logging to stderr by default * Make sure we have a volumes property before trying to use it * Prevent shadowing of the "context" module/parameter * Fail validation when an unknown property is supplied in a template * Validation failures now raise StackValidationFailed * vpc_test: move DependsOn to the correct template section * heat clients : Make heat-boto rollback disabled by default * heat clients : Change --disable-rollback to --enable-rollback * heat engine : Disable stack rollback by default * Add N802 rule to hacking.py * Add pyflakes to test-requires * Remove unused import from test_nokey.py * Create autoscaling instances in parallel * Separate public/private autoscaling adjust() APIs * Move instance polling into check_active() * Use oslo logging setup * Split resource create into create and check_active * Fix unit tests for Instance IP * Fix flaky unit test * Fix Unrecognized Attribute admin_state_up Error * Add breaks to for loops * Remove unused import from loguserdata.py * Allow heat to be used without a KeyName set * Do a metadata refresh after an explicit metadata write * Gate on certain pyflakes failures * Remove unused imports from repo in preperation for pyflakes * Add heat-watch to pep8 checks * Update infrastructure to more closely match other OpenStack projects * heat engine : fix hardcoded DisableRollback value * heat clients : make boto client library pass disable_rollback * heat tools : openstack script install mysql via openstack-db * Put heat data files in /var/lib/heat-cfntools * Depend on recently released python-quantumclient 2.1.2 Fixes bug 1133381 * Remove duplicate Mapper() constructor * heat engine : loadbalancer resource template, refer to StackId * heat engine : Re-resolve resource static data before create * heat engine : Compare runtime resolved resource snippets on update * heat engine : Set stack parameters AWS::StackId on stack create/store * heat engine : Add parser parameter support for AWS::StackId * Removes unused config settings from heat-engine.conf * heat engine : Make loadbalancer nested template raw string * Add waitcondition to loadbalancer nested template * heat engine : fix variable/import shadowing in service.py * heat engine : reinstate resources import * Update the metadata if an alarm action makes changes * Make the alarm actions run in one thread * heat : Only set qpid loglevel when rpc_backend specifies qpid * Use a short_id for naming S3 containers * Use a short_id for naming Swift containers * Add a module for generating random short ID strings * Make the exception string a little more useful * Remove compat cfg wrapper * Make quantumclient optional again * Get rid of unused imports * heat loadbalancer : make LB nested template create credentials * Protect AccessKey deletion from failing * Fix tarball tag to be empty rather than a point * Do not tag development releases "dev" * heat api : allow validation of YAML templates via cfn api * heat api : don't store whole request in ec2Credentials context * heat tests : fix run_tests.sh pep checks * heat : bump oslo-config version to fix import error * Add an attribute to InstanceGroup and AutoScalingGroup to return the ips * Remove "deny from all" line in wordpress config * Update GettingStarted with link to prebuilt images * heat engine : Add support rollback support for stack updates * heat engine : Update stack dependencies during update * heat engine : fail update immediately on resource update failure * heat common : Add ResourceUpdateFailed exception type * Add config for boto https_validate_certificates * heat engine : avoid returning empty resource error strings * Missing policy json files from tarball * heat engine : Implement rollback for stack create * heat engine : Only create periodic task on CREATE_COMPLETE * make stack_delete_after decorator tolerate deleted stacks * Use 2013.1 for Grizzly release version info in setup.py * Provide unit test coverage for AWS::EC2::SecurityGroup * heat cli : Add --disable-rollback option to heat-cfn * heat tests : delete stacks from DB in parser tests * heat api : Handle DisableRollback parameter in cfn API * make engine api handle string or bool disable_rollback * Throw a proper error if the flavor is missing * Add information about using the python-heatclient to the documentation * Make AvailabilityZone parameter available to nova create * Use oslo-config-2013.1b3 * heat engine : Add support for disable_rollback to engine API * Implement RouteTable and subnet association * Implement Internet Gateway and VPC attachment * Escape awk + sign so heat-keystone-setup works on Ubuntu 12.04 * Complete tests for NetworkInterface * Fix policy checks for users without policies * Use physical_resource_name for quantum/vpc resources * ip_version is mandatory for quantum create_subnet * Implement VPC Network Interface resource * Add Tags to vpc properties schema (Unimplemented) * Impement VPC subnet resource * heat templates : allow access to wordpress in example templates * Implement the "Volumes" property of Instances * Make the doc look a bit better and give a better overview * Add update support to InstanceGroup * Implement NetworkInterfaces instance property * Catch 404s when deleting quantum resources * Implement simple AccessPolicy Resource * heat templates : Remove IAM Policy sections * heat tests : split user test into User/AccessKey * heat engine : add option to control instance boto http/https * heat clients : Make boto client select http/https from configfile * heat scripts : Avoid using lsb_release in tools/openstack * heat api : Add policy.json authorization to cloudwatch API * Depend on WebOb==1.2.3 to align with other OS projects * Use yaml.safe_load: full yaml.load isn't needed * Add missing logging import * test_s3: use try_import from common * Refactor loguserdata.py so it can be tested * heat api : Add policy.json authorization to CFN API * heat common : context should split roles from X-Roles * heat tests : fix StackControllerTest name duplication * heat tests : remove duplicate import * Add cinder support to resource volume * Add initial code to support policy.json implementation * update openstack common and include policy.py * Remove unused heat/common/policy.py * Fix a few bash logic errors in install script * Remove sendfile as a dependency * Fix typo in AutoScaling update * Change install scripts to use cinder * heat engine : AutoScalingGroup UpdateStack support * heat engine : Resource add function to compare properties * heat tests : update_allowed_keys should be tuple * heat engine : Resource remove redundant None get defaults * heat docs : Fix version string issue * Update to latest oslo-version code * heat engine : WaitCondition add Handle property validation * heat tests : test_api_cfn_v1 move verify out of teardown * heat tests : test_waitcondition move cleanup out of teardown * heat tests : Add utility decorator for deleting stacks * heat api : add register_api_opts to init.py * heat engine : WaitConditionHandle use creation time for timestamp * heat engine : don't treat UPDATE_COMPLETE as failure * heat engine : pass fully resolved template to update * heat engine : Support Metadata update for Instance resource * heat engine : add Resource update_template_diff method * heat engine : pass json snippet into resource handle_update * heat engine : don't replace resource template before update * Hardcode provision-finished file path * Wait for deletion of Instances during creation * Fix Instance deletion in unit tests * Initial support for Transifex translations * heat engine : error on resource update with invalid properties * Store instance resource-id earlier * Make sure failures in groups (autoscaling & static) are raised * heat engine : AutoScalingGroup implement Cooldown property * Make flavor-list regexp more robust * Make a dedicated InstanceGroup * heat engine : ScalingPolicy implement Cooldown property * heat tests : autoscaling test add missing VerifyAll * heat tests : WatchRule test add missing VerifyAll * Use pkg_resources to detect version of cloud-init * A native Swift container resource type * heat_keystoneclient make token auth work * heat api paste.ini auth_uri should use auth_port * heat rename HEAT::HA::Restarter resource * heat engine : make WatchRule state message info * heat engine : make WatchRule initial state NODATA * heat tests : test_watch add tests for set_watch_state * heat tests : test_watch add create_watch_data test * heat engine : make watchrule actions run in stack ThreadGroup * heat tests : Add WatchRule evaluate test * heat engine : watchrule save state when actions undefined * ReST API: Don't overwrite webob error messages * heat tests : test_watch remove logging * ReST API: Return 400 for malformed JSON input * Typo error, "requied" -> "required" in run_tests.sh * openstack/common : rebase to latest oslo * heat tests : test_engine_service remove commented lines * heat engine : watchrule don't run rule for every SampleCount * heat templates : IHA enable cfn-hup * heat templates : fix IHA HeartbeatFailureAlarm during instance build * heat templates : IHA HeartbeatFailureAlarm should be Ref * heat templates : add missing credentials to IHA template * ReST API: Clean up exception-handling cruft * RPC API: Add a WatchRuleNotFound exception * RPC API: Add a PhysicalResourceNotFound exception * RPC API: Add a ResourceNotAvailable exception * RPC API: Add a ResourceNotFound exception * RPC API: Add a StackExists exception * RPC API: Add a StackNotFound exception * RPC API: Add an InvalidTenant exception * Prepare the groundwork for more exception types * Fix duplicate naming in unit tests * Get rid of unused initialisations in Resource * heat tests : remove debug print * Don't inherit from NestedStack * Move abstract nested stack class to separate file * Add a convenience method for deleting nested stacks * Only delete the flavors that the script will then replace * Make pip-requires a little F18 friendlier * Remove instance in ERROR state after failed create * Remove extras dependency with a partial oslo sync * heat engine : WaitCondition FnGetAtt return correct signal data * heat engine : Implement Count property for WaitCondition * heat engine : Add metadata validation to WaitConditionHandle * heat engine : implement metadata_update per-resource * Add auth middleware for custom cloud backend * Add configurable cloud backend * Trivial commit to make daily rpm builds work again grizzly-2 --------- * heat engine : DBInstance don't pass credentials to cfn-init * heat engine : LoadBalancer resource delete nested stack * heat engine : DBInstance fix so nested stack is deleted * heat engine : allow NestedStack template validation to work * heat engine : ensure create thread exits on stack delete * Handle different cloud-init versions gracefully * Add missing files to generated tarballs * heat tests : remove unused get_sftp_client() * heat tests : remove pointless get_ssh_client * heat engine : map DBInstance DBSecurityGroups parameter correctly * heat tests : functional tests align eip output with Folsom * Turn off tag_date on branch master * heat tests : CFN_API functional tests NoEcho Parameters fix * heat tests : functional tests remove erroneous finally clause * heat tests : convert stack ID to uuid format * heat tests : functional tests poll_glance cleanup * heat tests : convert functional tests to folsom glanceclient * Use correct stack_id arg name for metadata_update() * On master branch, tag tarballs as dev snapshots * RPC API: Simplify describe_stack_resources call * Use the new find_physical_resource RPC call * RPC API: Add a separate find_physical_resource call * CFN API: Fix DescribeStackResources with physical ID * Handle duplicate physical resources IDs * RPC API: Clean up list_events results * RPC API: Clean up list_stacks results * RPC API: Clean up show_stack results * Include new doc directory * run_tests.sh fixup venv/novenv logic * run_tests.sh cosmetic, make if/then style consistent * run_tests.sh cosmetic cleanup indents * update tox.ini to pep8 latest (1.3.4) * heat cleanups to align unit tests with pep8 1.3.4 * heat cleanups to align functional tests with pep8 1.3.4 * heat cleanups to align with pep8 1.3.4 * Fix DescribeStacks command for all stacks * ReST API: Improve format of resource_types response * Return an ARN as the Ref for nested stacks * Split nested stack implementation into abstract and concrete * Avoid logging.getChild for python2.6 compatibility * RPC API: Pass a stack identifier to metadata_update * Pass correct types in RPC Client unit tests * Update links in composed templates * A new documention structure, ready for contributions * pip-requires PyCrypto should be >= 2.1.0 * Add support for missing Instance attributes PrivateIp and PublicDnsName * GettingStarted: Install python-pip package * Fix issues with deleting a WaitCondition * Fix importing of novaclient exceptions * tools/openstack_ubuntu fix nova-manage network create command * Handle empty UserData for instance * Make resource registration conditional * Add a resource type list to the ReST API * Add an RPC API to list resource types * Standardise client imports * Fix ReST API documentation for template validation * install.sh non-root error should go to stderr * install.sh add logic detecting rabbitmq * tools/openstack fixup header formatting * Add ubuntu version of tools/openstack * install.sh simplify heat-engine.conf conditional * Remove heat-metadata man page * Get rid of naked "except:" clauses in tests * Don't skip watchrule test on exception * Get rid of unused imports * Get rid of nose.main() in unit test files * heat_keystoneclient ec2 user fix * Move the cfn client code to a subpackage * heat cfn api, format waitcondition error responses correctly * Override events for AutoScalingGroup instances * resource state_set, abstract update/store logic * Don't allow identifiers with slashes * Don't allow slashes in Stack or Resource names * Move resolved template comparison to stack update * Fix race condition in list_stacks * Get rid of glanceclient dependency * heat engine : convert WaitConditionHandle URL to ARN format * heat : Add HeatIdentifier from_url function * Eventlet monkey-patch heat-api-cloudwatch * Eventlet monkey-patch heat-api-cfn * Eventlet monkey-patch heat-api * Add test to simply run a few binaries * Switch over missed file in version switch * Don't pass -1 as a stack_id in unit tests * Make Volume tests independent * Clean up the volume test * Fix Instance unit tests * Add back catch_error which is used for CLI errors * Switch to openstack style versioning * Update openstack-common to get newly fixed version.py * heat-db-setup read engine config file for DB connection details * Don't get nested stacks by name * Fix exception handling in AccessKey fetching * Move utils.py to a more appropriate location * Get rid of leftover heat-jeos code in utils * Get rid of pointless cloudformation.py file * Get rid of the cfn_helper tests * Enable VPC unit tests * Enable Quantum unit tests * Get rid of naked except: clauses * heat : Update getting started wiki links * heat : Clarify openstack versions for Fedora releases * heat : Update repositiory in getting started guide * Add version.py from openstack-common * Do not wrap exceptions during quantum resource delete * Update openstack-common * Use common implementation for fetching templates * Add a common implementation for fetching a URL * Pass string to template_format.parse() * Resource.__eq__ allow resources in different stacks * Fix importing of quantum resources subpackage * Do the same install_requires as other projects * Install extras during pip install; fixes devstack * heat remove unused config options * heat getting started, add pip install extras * heat engine : remove KeystoneClient get_user_by_name * heat engine : Rework AccessKey to avoid keystone user lookup * Make sure heat uses its own control_exchange * Make default encryption key long enough for unit tests * Update the README with more current links * Add VPC resource implementation * Update .gitreview for org move * Use pkgutil to load cloudinit data * Use module names as logger names * Add a plugin directory for Resources * Automatically register engine options * Move db crypto code out of the engine * Create a new heat.rpc package * Move template-format parsing code into common * Move the identifier module into heat.common * Remove gen(erate)_uuid from heat.common.utils * Remove is_uuid() from HeatIdentifier class * Use uuidutils from openstack-common * Add uuidutils from openstack-common * Update openstack-common * Remove heat-metadata service * heat engine : Convert WaitConditionHandle to pre-signed URLs * heat engine : subclass keystone client to encapsulate common code * Process engine config before initialisation * heat api : add waitcondition to cfn api * Add documentation on plugin_loader module * Lookup the class for an Instance in Autoscaling * Refactor autoscaling Instance creation * Load resources dynamically * Add a module for dynamically loading plugins * Distribute resource mapping to individual modules * Move the resource module out of the resources package * Remove YAML template trailing spaces * Convert some existing templates to YAML format * For Fn::Join join strings in resolve_static_data * Set default empty dicts for missing sections * Don't assume parsed JSON in REST API * cfn-json2yaml file-mode bugfix * pip-requires fix boto version * Utility to convert JSON template files to YAML * For tests, Parse all templates with parse_to_template * Parse all templates with format.parse_to_template * Module for converting JSON to YAML, and parsing both * Add packages and versions in response to grizzly-1 * HAProxy example had incorrect descriptions * ReST API: Add Events * CFN API: Rename ID formatting method * RPC API: Return an identifier for events * Use the new class for database access to Events * Add a class to represent Events * Add a method for querying a resource's type * Add identifiers for Events * Improve the identifier class for Resources * Get db session from the context * Use a real context for tests * heat engine retrieve credentials every periodic task interval * heat engine Add admin flag to dbapi stack_get * Tool to download all Amazon example templates * r1 not defined * Remove unused statements/local assignments * heat engine allow WatchRule load() from DB object * heat engine move to per-stack periodic watch threads * add watch_rule_get_all_by_stack dbapi call * Make CloudWatchAlarm names unique per-tenant * WatchRule refer to stack by id not name * Provide more information with template URL error * Add missing logging imports * Use jsonutils in ec2token * Remove unused imports * Fix ppetit.template parameter type Integer -> Number * RPC API: Get rid of event_create call * ReST API: Add a convenience redirect for resources * ReST API: Add API for Resources * RPC API: Include less detail in resource list * Refactor unit tests for ReST API * ReST API: Move remote error handler to utils module * RPC API: Return a resource identifier * Add identifiers for resources * ReST API: Refactor routes * heat engine : remove now-unused metadata rpc calls * heat workaround for HA/Autoscaling regression * heat dbapi rename stack_get_by_tenant * Allow stack.owner_id to store a uuid * ReST API: Split utilities into a separate module * Actually validate properties of resources * Getting Started: Fix formatting errors * heat templates : align autoscaling alarm descriptions with values * heat engine : create boto config via instance userdata * heat engine : append watch server url to instance userdata * Don't use OpenStack plugin in tox * Always filter by tenant_id in stack_get_by_name * Align pip-requires versions with nova * heat align openstack/common with latest oslo-incubator * Modify identify_stack to check for uuid * heat engine : Don't wait() for killed greenthreads * Pass a Stack entity to Stack.load() * Switch to UUID for the Stack primary key * Add a list_stacks RPC call * Rename instance_id to resource_id * Move client connection out of resources.py * Fix FnGetAtt id test * Fix cloud-init runcmd to be exec friendly * Replace KeyStoneCreds params with X-Auth headers * Quantum template to demonstrate floatingip * Make Boolean property a bool type. Since json has a native bool type, allow bool or string as the property value. Validating a Boolean type value will now convert a string to a bool * A template which associates an instance with a Quantum port * Type is now mandatory. Boolean now exists * Handle list properties that do not contain objects * Remove the CheckedDict class * Use new Parameters class in unit test * Get rid of Resource.calculate_properties() * Add a Properties implementation with lazy loading * Avoid modifying the Properties of a Load Balancer * Fix schemata errors for properties * Add a set of native quantum resource types * Recursively replace all : with . in Output keys * Rename heat client to heat-cfn * Update openstack-common, add network_utils * Use openstack-common service.py * heat templates : Align AutoScaling template with cfntools * Add service.py from openstack-common * Update openstack-common * Implement NoEcho for parameters * Use new Parameters class for validation * Separate Parameters implementation from Properties * Clean up hacks for parameter passing in unit tests * Put the Template class in its own file * heat-keystone-setup : fix error on folsom first-install * heat engine : add heat_waitcondition_server_url * heat metadata : Remove all non-waitcondition related logic * heat metadata : remove metadata_url logic * Format stack_identity as id *and* links * Move resources into a separate sub-package * Move Timestamp code to separate file * heat-keystone-setup : change role to heat_stack_user * heat engine : add template-defined users to keystone role * heat engine : Allow instance users to view their own details * heat-keystone-setup add instance role * heat-keystone-setup workaround keystone arg syntax * heat-keystone-setup workaround keystone output reordering * heat tests : StackBoto fix _check_*_result functions * heat tests : refactor stackid check into utils.Stack * heat tests : fix CFN_API_Actions test fix state reason * heat tests : fix CFN_API_Actions test stackid regex * heat engine : kill running greenthreads on stack_delete * heat engine : Store all resource states to DB * Bump version to v8 v7-branch-eol ------------- * heat engine : Make Resource::swift handle auth_token * Cleanup runcmd to exit 0 and not use 'type' * ReST API: Add a keystone endpoint * Handle %(tenant_id)s in endpoints when updating * Change the service user to match devstack * Pass the correct tenant for the service user * Start and enable libvirtd * heat engine : Resource.keystone handle auth_token * heat engine : Rework auth.authenticate * heat engine : remove unused EC2 style auth from engine * ReST API: Format output as JSON * Do not assume host has selinux utils installed * Identify stacks using tenant UUIDs * Make default distribution U10 for deb template * heat engine : Make wait-condition poll interval better * Handle upgrades in heat-keystone-setup * Rename CloudFormation service to heat-cfn * heat tests : Remove utils.Stack getter methods * Use password in preference to token if both supplied * heat tests : add ValidateTemplate test to CFN_API_Actions_Boto test * heat tests : Add ValidateTemplate test to CFN_API_Actions test * heat API : ValidateTemplate fix response format * heat : heat cli pep cleanups * heat : boto_client_cloudwatch allow credentials override * Catch SSH Disconnection errors in functional tests * heat : add template-swift-url option to client * heat cli: encapsulate template arg-parsing * heat engine : remove unused validate_template params * Obey the passed in distro value in HAProxy template * Use --script option to parted in templates * Reduce timeout periods in functional tests * ReST API: Add unit tests * heat : Getting started updates for Cloudwatch * Getting Started: Fix IP address determination on F17 * heat engine : Move watch logic into WatchRule class * ReST API: Report template validation errors * ReST API: Return appropriate error codes * ReST API: Separate out code to fetch template from a URL * heat : db API add watch_rule_get_by_name * heat : db API add watch_rule_update DB API action * heat : Remove cloudwatch functionalty from metadata server * heat templates : Add boto config to HA templates * Unit test for load balancer resource type * heat : Add missing calculate_properties to user resource * heat engine : Avoid printing credentials to logfile * heat engine : only attempt stack update from valid states * ReST API: Add some simple API documentation * ReST API: Use JSON documents for data input * ReST API: Refactor handling of input data * ReST API: Fix template validation * heat : workaround engine error with version code * Change endpoint service type from orchestration to cloudformation * Fix versioning code * Remove unnecessary keystone scripts * Fix bugs in ReST API stack creation * Allow authentication to Nova with a Keystone token * heat engine : workaround lack of no_cache on essex * Avoid create_stack RPC call timing out on precise * Fix hash-bang directive in nova_create_flavors.sh * import gettext to fix db migration execution * Make sure to remove python-glanceclient too * heat tests : add functional test for UpdateStack * heat tests : functional utils support for UpdateStack * heat tests : Add new boto API test * Add the beginnings of an OpenStack ReST API * heat tests : API test fixup for ResourceProperties * Allow separate versioning of each API * heat API : return ResourceProperties as JSON * Move CloudFormation API to heat.api.cfn package * Make the keystone service type configurable * Unit test for DBInstance resource * Add a Folsom specific heat-keystone-setup binary to bin * heat engine : format stack outputs for updated stacks * heat : fix glanceclient deprecation warning * Fix test_waitcondition.py race by converting to mox * Rename heat/cloudformations.py to heat/cloudformation.py * Trivial unit test changes * Switch to in-memory sqlite for unit tests; 1500% speed improvement * Move test skipping on import failure from package to function * Get rid of gratuitous params in RPC API * Unit test coverage for user resources, plus some user fixes * Change file to executable to get rid of rpmlint warning * Version 6 about to be announced for release, time for v7 v6.release ---------- * heat : HA functional test missing import * heat tests : convert HA test to exec_sudo_command * heat tests : Fixup IHA functional test * heat tests : functional tests add exec_sudo_command * Don't fail to delete if VolumeAttachment not found * Improve debugging ability for functional tests * Fix typo in test file name * heat tests : fixup test_CFN_API_Actions.py * Stop deprecation warning when creating resources directly * Unit tests for volumes and attachments * Update another embedded template to F17 * Changed embedded loadbalancer template to use F17 * heat API : fix wrongly named key for stack events * heat : ensure DB user creds aren't written decrypted * Fix scoping issue * Make instance match expected name * Look for instance name that matches template * Provide full URL address in AutoScalingMultiAZSample.template * Tag functional tests with the JEOS required * Make automated scripts quieter * Implement test_AutoScalingMultiAZSample.py * heat engine : loadbalancer add missing calculate_properties() * heat engine : convert stack resource to physical_resource_name * Return exit code rom run_tests.sh * Avoid test runner crash when we have no tty * Unit tests for autoscaling resources. 100% coverage! * heat tests : New wordpress IHA functional test * Tests EIP resource creation and association * Allow linux distribution to be passed to multiaz template for test case * Fix backtrace when using loadbalancer * Fix spelling errors in loadbalancer which resulted in template not launching * Remove unnecesssary nova constructor calls in each manager API call path * Fix up tags * Fix test_WordPress_2_Instances_With_EBS.py * Change templates to launch F17 (not F16) by default * heat tests : add HAProxy functional test * heat templates : add LinuxDistribution parameter to HAProxy * heat tests : functional tests allow non-default stackname * Switch to Fedora 17 on guests in Getting Started * heat : Show user parameter values in heat describe * heat tests : expose keyname from Stack object * Work around nova-network launch issue harder * Use stack_identity where it has changed from stack_name * Unit test S3 Bucket resource with associated fixes * Use openstack.common.timeutils.isotime() * Work around nova-network launch issue * Change rpc cleanup to occur before killing engine thread * Add new OpenShift test * heat tests : new functional test for CFN API * heat tests : Update test_WordPress_With_RDS * heat tests : remove duplicate cleanup Wordpress_Boto * heat tests : bugfix utils cleanup function * heat tests : bugfix utils cleanup * tests: Wait for delete completion * tests: Clean up after a failed functional test * tests: Make StackBoto inherit more from Stack * tests: Fail promptly on stack creation failure * Add Wordpress_2_Instances testcase * Add test_WordPress_2_Instances_With_EBS_EIP.py * heat tests : functional test utils add response_xml_item * Fix timing issue in starting openstack-network * There is no spoon take 2 * There is no spoon * heat : Revert "Make sure the properties are defined in all cases." * heat : bugfix convert User resource to physical_resource_name() * creating instances failed as a result of regression in last commit * Update openstack-common * Make physical resource names unique based upon stack name * Change Stack to support user defined parameter * Add 2 instance with EBS test * Change VerifyClass to have a generic verify_url method * Update WordPress_Compsed_Instances to new test infrastructure * Make S3 import except on ImportError rather then all exceptions * Make S3 optional since swiftclient is not available in all distributions * heat : test utils, extract ec2 credentials from keystone * heat : allow boto_client to accept credentials * heat : move boto.cfg to correct location * heat : comment credentials in template boto.cfg * heat tests : add new Boto wordpress functional test * heat tests : functional test utils add StackBoto class * Implement the AWS::S3::Bucket resource type * Update documentation on configuring metadata server * Handle verification errors in create/update in cfn API * heat tools : nova_create_flavors.sh additional retry logic * heat tools : add ephemeral disk for all flavors * heat tools : check services running after openstack install * Rework functional test case infrasatructure * Add a string representation for identifiers * Add unit tests for EngineManager create/update/delete_stack * Fix update_stack call in EngineManager * Reorganise etc directory for easier installation * Delete unused heat-engine-paste.ini * Make sure the properties are defined in all cases * Add test case for WordPress_With_LB.template * Add a Wordpress+MySQL composed instance functional test case * Add EBS test * heat tests : new wordpress EBS_EIP functional test * Forgot commas, doh! * More EBS fixes * Rename heat-api to heat-api-cfn * heat templates : EBS templates, attach volume to vdc * heat tests : bugfix FuncUtils check StackId not StackName * heat templates : Add default LinuxDistribution parameter * Fix identify_stack call * Modify to use systemctl and move func_utils outside of setUp * Add a newline to user data injection * Fix pep8 warning * Support lookup of stacks by name or ARN * Add an identify_stack RPC call * Report StackId in ARN format * Create a unique identifier for stacks * Use assertEqual() instead of assert_() * heat tests : add functional test for Wordpress RDS * heat tests : convert functional test to class * heat tests : update WordPress_Single_Instance_With_EIP * heat tests : convert functional test to testcase class * heat tests : FuncUtils use heat_client in create_stack * heat tests : FuncUtils cleanup use heat_client * Switch to keystone service_type=orchestration * heat tests : test_WordPress_Single_Instance.py update * heat tests : Add verify_wordpress helper function * heat tests : FuncUtils add get_stack_output function * Fix support for eventlet 0.9.16 * heat tools : add qpid-cpp-server-daemon to tools/openstack * Add functional test for HA template * heat : run_tests.sh allow easier test selection * heat cli : initial heat-watch cloudwatch API client * heat API : Implement initial CloudWatch API * heat engine : Add set_watch_state engine RPC action * heat engine : Expose valid watch states via engine.api * Add new functional test for WordPress_Single_Instance_With_EIP * Connect to heat client, add accessor method, and fix ip check * Add new methods to get access to nova/glance clients * Make sure the functional test always cleans up * heat API : add get_param_value to API utils * Add new arguments to run_tests * Refactor reformat_dict_keys() * Refactor extract_param_pairs() * Refactor extract_param_list() * Add link to RPM repository in getting started * heat API : Add api.aws.utils.extract_param_list * heat tests : rename test_stacks * heat tests : add test for new manager show_watch_metric method * heat tests : add tests for new manager show_watch method * heat engine : bugfix show_watch, fix single-watch mode * heat tests : add new engine rpcapi unit tests * Add test-requires in RPM package list form * Set the max url length in eventlet 0.9.17 * Functional test improvements * Fix the Timeout/Interval check in the LB * Fix the way self.properties is checked for a value * Make RDS (mysql) wait until setup is finished before proceeding * Put selinux in permissive mode by default via a runcmd in cloudconfig * heat API : make extract_user_params more generic * heat engine : Add show_watch_metric RPC action * heat engine : add show_watch RPC method * Split functional test into standalone and utility class * heat DB : make watch_data_get_all work with no watch ID * heat API : Add HeatAPINotImplementedError exception * heat API : Move aws api common code into aws/utils.py * heat API : move remote_error to common exception.py * heat API : move aws common files from api/v1 to api/aws * heat engine : Fix engine.api variable shadowing * heat tools : glance-jeos-add-from-github avoid duplicates * heat tools : glance-jeos-add-from-github scrape image names * Inject command into userdata * Add a tool to register prebuilt JEOS images into glance from github * heat template : Align two Openshift template varieties * Use cached keystoneclient * heat cli : Workaround inconsistent boto return type * heat cli : Rework to separate cli tool from client-API wrappers * heat cli : remove some duplication from parameter formatting * heat cli : remove unused paths from heat cli tool * Update Getting started to match change to heat-jeos * heat api : bugfix, save config correctly in EC2Token * heat templates : Add openshift template for pre-built jeos * Getting Started: Add configuration info for the metadata server * Getting Started: Use install.sh script * Make template params resolution standalone * change amd64 reference to x86_64 to match latest cfntools * Remove crankcase patch since fix was merged upstream * Add calculate_properties() to update() and restart_resource() * Force rpm to retry indefinately during crankcase build * Log all startup operations to /var/log/heat-startup.log * Port existing rpc calls to use the new RPC client API * Implements a client side engine RPC API * heat templates : update Openshift template to add node instance * heat : Make instance flavors consistent * heat engine : raise appropriate error for incorrect stack_name * heat API : Return correct AWS error response for invalid parameter * Bump to v6 v5.release ---------- * heat engine : Avoid writing to class-scope parameters schema * Update getting started with credential crypto * Add tools directory to python package * Don't use uuidgen in install.sh * Add encryption support for authentication information in db * Change to per-tenant stacks * Make a template that demonstrates instance monitoring and restarting * Call calulate_properties() before calling FnGetAtt() * Log the error when a resouce fails to delete * heat API : Add more tests covering error paths * delete duplicate validate() method * loadbalancer: implement Interval and Timeout * autoscaling: implement DesiredCapacity * Update GettingStarted guide to use correct state name * Get rid of PyCrypto dependency * heat API : Add more unit tests * Add AWS::RDS::DBInstance * autoscaling: don't kill all instances when scaling down * make the autoscaling template easier to debug * Return the name from the autoscaling group not the instance * Add python-psutil and fix cfn-push-stats options * Add an EC2Token_filter_factory and use it as the default paste filter * heat api/engine : Implement UpdateStack functionality * heat db : fix per-object delete * Combined autoscaling and loadbalancer * Optimize filter context * convert to float instead of int in the watch rule * Allow nested stacks to be retrieved by name * Use eventlet's wsgi again * Don't require user params on template validation * tools: erase openstack-utils only after using it * Update openstack-common * Erase openstack-utils when uninstalling OpenStack * heat : update config files with new rpc backend * Import openstack.common.rpc * Use global cfg.CONF instead of config classes * Get rid of eval() in authentication code * heat engine/API : Internal API rework * Account for XML output in Getting Started script * Fix directory changes in Getting Started script * Allow non-interactive installation of OpenStack * Document Metadata server in Getting Started guide * Import openstack.common.log and use inside heat infrastructure * Update openstack-common in prep for pulling in common.rpc * Set the stack updated time through the Timestamp * Eliminate DB access from the engine API * Make timestamps available in Stack/Resource objects * heat cli : Manpage updates * heat engine : fix create_stack response format * heat API : Add missing StackId prefixes * heat engine : move StackId formatting into API * Block on instance delete until delete operation completes * heat engine : Store stack timeout in database * Display better message on Keystone failure * Speed up metadata server registration * Fix the WordPress puppet template syntax * Optimise DB lookups by ID * Raise the correct error when a stack is not found * Access Resource metadata through the new attribute * Add a helper class for metadata * Add unit tests for metadata read/write in heat-engine API * Avoid unneccesary template parsing * Allow partial template parsing * Rename resource_id to resource_name in metadata API * Report errors from nested stacks * Speed up engine manager unit tests * Update JEOS example in Getting Started * heat cli : Align resource-list-details usage with other commands * heat API: bugfix to XMLResponseSerializer * heat engine: raise appropriate error on bad stack name * Add DB refresh/expire on specific parameters * Allow Status(Reason) access through Stack/Resource objects * Rename test_resources to test_instance * heat API : Return auth errors in AWS format * heat : heat-boto remove boto.cfg reading * Separate out formatting for Engine API from manager * Add new assertions about event unit tests * Add basic autoscaling * Add NovaSchedulerHints and correct the implementation of Tags * heat tools : openstack script don't create duplicate pv's * heat tools : openstack script add restart option * heat tools : whitespace cleanup in tools/openstack * heat tests : Add missing headers to tests * heat API : cleanup docstrings * Add monitoring to the loadbalancer * Add an OpenShift template * Pass Tags into scheduler_hints * heat tools : heat-db-drop prompt for missing password * heat API : Convert API to use HeatAPIException subclasses * heat API : Implement API specific exceptions * heat : add heat-boto test client * Add more unit tests for the engine API * Store the context in the resources * Add Metadata to detailed Resource output * Use a consistent stack ID * Make Stacks the owners of their own DB representation * Don't store the metadata server address in the Stack * Delete user creds from DB when no longer required * Remove parsed template from database * Make LoadBalancer a subclass of a nested stack * Use unittest assert*() methods instead of assert keyword * Switch .gitreview to use OpenStack * Add the loadbalancer resource * Add the Fn::GetAZs() intrinsic function * Teach CheckedSchema to do nested schemas * heat API : Add missing Response wrappers * heat API : Make CreateStack work with boto * Add unit tests for timeout extraction * heat API : DescribeStacks return all when no stack name specified * Fix typo in stack creation code * Change oz rpm install to use yum * heat engine : Return timestamps formatted by heat_utils.strtime * Clean up pip-requires for stackforge * We don't need to be installable via PIP so remove build and install deps * Don't go fishing in the stack for the KeyName * Tidy up create timeout code * Get rid of _wrap_db_error() * Bump to v5 v4.release ---------- * Store the user parameters in the stack table * heat GettingStarted guide, add oz install instructions * Add nested templates that implement a simple proxy/loadbalancer * Pass the stack_id into the resource_metadata_update * Do not remove qpid-cpp-server as it is part of openstack erase * Few small fixes for getting started * Remove --root=/ in install script * Add keystone create script for devstack * heat API : Align DescribeStacks response with AWS docs * heat API : Escape JSON TemplateBody XML serialization * Add uninstall script for Heat * Factor out authenticate method for engine * Fix metadata startup * Change install.sh to work on fresh install * Fix path to cloudinit directory * Ignore the unimplemented properties of IAM::User * Don't use json.dumps() on the output of get_template * Fix EIP template * Remove service name from nova() def * heat API : Add support for ContentType=JSON query parameter * Fix Stack initialisation * heat templates : Cleanup README and template whitespace * Fix the wait condition's reading of the metadata * Fix a typo (from the commit to use state instead of parsed_template) * Use the correct resource name * Make the describe-resource API calls user-aware * DB: add stack status & reason, resource metadata * Use the resource.state_description * Don't remove resources from the DB during HA restart * Make the saving cfn-signaling more reliable * Remove duplicate setup_logging() * Work around keystone strangeness (error deleting user) * Fix db exception description * Fix the metadata rpc functions * heat API : Align response StackId with AWS spec * Add more per-user stack support (2) * Add example templates for nested stacks * Add execute bits to executable scripts manage.py and runner.py * Fix DB calls in Resource API * Add describe resource API calls * heat api/engine : Reworked approach to aligning with AWS date format * heat API : Align time format with AWS spec * Lengthen the timeout of the WaitCondition in the HA template * Change create_watch_data from POST to PUT * Get the context from the db not the context of the guest tool * Implement Nested Stacks * Move parsing of parameters out of template parser * Get stacks from the DB by either name or id * Lock to pep 1.1 * Fix latest DB migration script * Raise NotFound exceptions from database * Tidy up Resource creation and deletion * Do proper dependency calculations * heat manager : rename dict keys to align with AWS API * Add a better error message * Add a user creds database table and associate stacks with username * Fix the metadata server auth (KeystoneCreds only sent from heat) * Fix the error reporting * Add manpage for heat-metadata * heat API : return response body as XML not JSON * Add heat-db-setup.1 manual page * Pass Full Credentials to Engine * Implement the user/access keys using keystone * Allow an already deleted watch to not fail the stack.delete() * Delete redundant escalation_policy (rather use instance.restarter) * Make sure create happens if a resource has been deleted * Make sure the 'nova_instance' is refreshed when ever the state changes * When restarting a resource make sure that the parsed_template_id is set * Fix heat-jeos installation in Getting Started * Make heat-keystone-service a tad more robust * Add install.sh * Add EstimateTemplateCost API * Add the GetTemplate API * Remove cfntools and jeos * Convert getLogger(__file__) into getLogger('heat...') * Add a Timeout (-t) to the heat options (and make -f for templates) * Fix the setup of daemon config * Update openstack-common * Improve parser readability + add unit tests * Fix parsing of metadata * Rely on instance_id been set to None * wait_condition: use properties not t['Properties'] * Fix cloudwatch delete * Fix restart_resource() * Pass the context to the db calls * add user auth to ha template * Make sure the resource exists before trying to update it * Fix the conversion from instance to resource name * Restructure watchrules to make them more testable * Add missing properties to cloud watch * Change command interpreter to bash * Add qpid-cpp-server to the openstack setup script * Teach heat-api about the bind_host * Refactor template resolution * U10 wordpress template * Fix new pep8 warnings * Fix the Getting Started guide for the new setup.py * Refactor Resource creation * Clean up imports * Don't use sys.exc_value * Get list properties working again * Remove _authenticate() check for metadata calls (temp) * Fix the HA template (sed the username/password) * Fix apt-get install * Remove python 2.7ism * Compress qcow2 files to take up less disk space * Install argparse and update the U10 package cache * Fix auth failed exception handler * Set stack's `updated_at` time * Add instance restarter * Add a name to the checkeddict to improve the error messages * Authentication Overhaul * Changed SecurityGroups property type to TuplesList * Change the policies for User to TuplesList * Add missing flags to enable working with RabbitMQ * cloudwatch: set HA template to send watch data * Add the basic cloudwatch feature * Add missing "properties_schema" to WaitConditionHandle * Fix jeos_path when not intalled as an egg * Allow login to U10 jeos launched from heat * Changes to checkeddict for tuples and required * Make i386 cfntools jeos work * Add U10 JEOS support to heat jeos_create * Validate all resource properties * Add functional test to verify jeos and stack ops * Fixing variable name for debug message * using the calculated path for the template tests * Update resource statuses in the database * Fix deletion of security groups * Only run cfn-init once * Use the new CheckedDict for Parameters * Add some better checking for parameters and properties * Fixing path lookup to make sure the templates can be found * Adding the AWS::IAM::User and AWS::IAM::AccessKey to the mapping * tools/openstack: Updated to latest openstack F16/F17 tools * Update gitreview for new Stackforge remote * Align with project standards * Fedora openstack projects use new tools to setup databases * Add .gitreview for Gerrit * Add an integration test script * Pep8 fixes * Fixing _decompress to handle bundled and compressed * Handle failures when deleting stacks * Fix problem with updating parsed template in DB * Fix copy-paste errors in template descriptions * Improvements to uninstall script * Refactor some not-particularly-Pythonic code * Delete networks when erasing OpenStack * Adding chaining to CommandRunner * Making PrivateDnsName return the ip address * Adding puppet and puppet master instances * Wait for instance startup in GettingStarted test * api : fix pep8 warning * Allow engine and metadata server start in any order * Making PrivateDnsName return the ip address * Clean up the API routes * Adding puppet and puppet master instances * Clean up the API routes * Make the wait condition behave better when the stack is deleted * heat cli : Add options to bash completion script * heat client : reduce duplication between functions * API and heat-cli rework to align with AWS CloudFormation API * Report errors when resource creation fails * Modify command names for consistency * Updated the version to 4 * Make 'heat help' show a list of commands * Allow the Getting Started script to run non-interactively v3.release ---------- * Fix pep8 errors * Set cfn-hup to send events to the metadata server * Slim down the getting_started template * Check for the presence of Metadat before trying to include it the multipart * Add status argument that shows service status for all required services * Kill some pep8 errors in test_stacks.py * Kill some pep8 errors in engine directory * Kill few pep8 errors * Properly test ref valid against proper input * Use manager to test ref validation * Add test cases to test valid and invalid keys in FindInMap * List stacks tests * Move list_events into the class * Factor out a start_wordpress_stack() * Add event_list test * Add uninstall script * Add Getting Started guide to repo * Add cfn-get-metadata to the manifest * Fixed problems with starting MySQL in heat-db-setup * Add test_validate_ref for invalid and valid inputs * Check for invalid Fn::FindInMap key * Check for invalid Ref keys in validate * TEST: slightly better version with minimal template in place * Add volumeattachment validation * Allowed the database call to return no parsed template * Adding a deepcopy of the template before stack create validation * Add stack delete test, and set stack to DELETE_COMPLETE when done * Removing stack validation on create * Adding stack create test * Validate invalid mountpoint.device entries * Allow sending events using metadata server * Typo in a logging declaration * Fix stack creation - CREATE_FAILED issue * Add ability to automate testing with tox * Add option to exclude pep8 examination to run_test.sh * Add test coverage option to run_tests.sh * Connect up the waitcondition code to poll the metadata for the signal * Save to parsed template as that is used in the parser * WaitCondition: fix the url to the new metadata server * Add WaitConditions to HA template * Download cfn tools from the master branch * Escape the quotes going into cfn-signal shell command * More peppy fixes.. * Add implementation to cfn-signal * Fix undefined LOG variable in db.session * Remove unused "cloudinit_path" setup in resources.py * Metadata: Add bind_host to the config * Register metadata server's entry point with Engine * Remove obsoleted metadata files * Connect metadata server to the engine via RPC * Moving key validation into instance validate * Apparently boto expects / to be list stacks * ValidateTemplate API call framework * Fix the sql in the rails template (didn't work with the mysql in f16) * uncommenting the metadata server attribute so the tests work * Validating the KeyName against nova on stack_create * Connect cfn utils to the remote server * Fix cfn-get-metadata params and output * Fixed the interpretation of the file extension * Only showing the Outputs when the status of a stack is CREATE_COMPLETE * Fix unbound error in cfn_helper * Adding mime_string to the Instance instance and fixing tests * Fix some indentation and pep errors * Hack the Rails template to work * Add Rails template example * Add dummy cfn-signal * Add WaitConditions * Split the resourses up into seperate files * Handle "sources" in cfn-init * Initial metadata server API * Add very basic support for installing (apt, python & gems) * Add cfn-get-metadata to files section of cfntools tdls * Modified README in tools directory to explain a few more tools * Scoping the session per thread (request) * Oops, meant for website repo * Heat Logo * Skipping the import if its deps aren't installed, use --no-skip if you want to run this * Copied the python-novaclient test code to avoid importing via python path * Adding the metadata.log file * Finish necessary changes related to jeos_create move * Add skeleton structure for the metadata server * Update heat-api docstring * more pep fixups * Add cfn-get-metadata make all cfn tools more consistent * openstack-common: timeutils and importutils seperated out * openstack-common: update cfg.py * Move jeos_create into utils so it can be imported * Put Starting Heat API in log file and add logging setup to bin/heat-api * Remove stray print debug message * Quiet down the QPID logging since it isn't helpful and makes logs hard to read * Kill prints and replace with LOG in heat/rpc/__init__.py * Stub out system calls in metadata_files test * Implement runas for cfn-hup * Add test artifacts to gitignore * Handle cfn-hup non-value parameters * Moving db error wrapping into heat session to avoid a nova import * Add an easier way to update the cfn scripts * Fix up the template - some scripts not right * Fix the cfn logging * Fix userdata mime creation * Fix userdata mime creation * Add a real creds file for the cfn-hup config tests * Re-add the file logging to cfn tools * Make sure AWS::StackName is avaliable * Add cfn-hup config into template * Copy the single inst. wordpress template to With_HA * removing import of common config because it needs credentials * Adding the nova.exeption import to fix the tree * Add file support to cfn-init * Adding instance delete test * Log when cfn-hup couldn't restart a service * putting python-novaclient back in pip requires * Removing nova from pip requires * Make heat-db-setup generic enough to run on RPM or DEB distributions * Adding the nova module to the pip-requires * removing import of common config because it needs credentials * Adding the nova.exeption import to fix the tree * Use pip package name, not the RPM one * Update virtual-env requires and documentation * Make cfn-hup configuration handling closer to aws * Better error messages for cfn-hup configuration * more work on cfn-hup * Add test case for boolean * Assert the instance auto increment on the id worked * Removing the run_tests.py, was replaced by heat/testing/runner.py * Changing version scheme to just major * Adding instance creation test * Fix `to_boolean` in cfn_helper * Try and keep track of the stack status * Added db setup and teardown with sqlite * Adding unit test for instance creation * Adding resource initialization test * Adding instance creation test * Added db setup and teardown with sqlite * Adding unit test for instance creation * Adding resource initialization test * Initial cfn-hup (wip) * Move common cfn code into cfn_helper.py * Fix more pep8 errors * Update version to v3 v2-M1.release ------------- * Wordpress 2 instance with EBS and EIP * heat cli : Add bash_completion.d entry for heat * heat cli: Use python logging module * Fix another print -> logger.warn * resources.py had a bunch of print's in it * Add an exception around EIP fetching * Fix a typo in the command line help * Use v1 / v2 / v3 for version numbers to match tags * Set proper author and mailing list in setup.py * Remove BUILDING.rst since there is no building taking place inside project * Remove rpm spec file and Makefile. Will track packaging in a different repo * Remove tito - likely track this in a different repo * Fix the EIP cleanup * Add documentation for the per command CLI help options * heat, heat-api: Add missing licence to header * Remove rootpw from tdls and add ec2-user to sudoers file * Deleting parsed and raw template when deleting stacks * A little more detail on network create * Fix the test environment * Fix another template attribute in the output section * Use the correct api to get the volume object * Save the resource if complete or failed * Fix the delete of a volume attach when the create partially succeeded * To properly populate the output section * Use the instance_id for the event "physical_resource_id" * Fix the output attribute in single instance wp template * Save the parsed_template so user parameters are available * Fix the parsed_template columns (missing created_at and updated_at) * Fix the version file (don't import glance's git commit) * Add WordPress_Single_Instance_With_EBS_EIP.template * Rename EBS_Volume to just EBS to pave way for EBS_EIP * Make WordPress_Single_Instance_With_EIP.template work * Initialize sec to None to avoid exception in security group * Fix invalid JSON in template * Store all event data in DB * Remove hard-coded paths from DB setup script * Avoid printing exception in db-setup * Handle exception on Ctrl-C * Updated WordPress_Single_Instance.template to work properly * Update templates README with list of secure vs insecure templates * Make WordPress_Single_Instance_With_EBS_Volume.template functional * remove old experimental code * kill all pep8 errors in parser and resources * Updated templates/README directory to more clearly explain templates * Rename WordPress_Single_Instance_cfntools.template to not have cfntools in name * Rename WordPress_Single_Instance.template to have gold in name * Adjust cfn-init -f flag to be implicit * Adjust cfn-init to not use -f option * Adjust cfn-init to not take a parameter in the initialization * Fix bug in path on cfn-init * Fix for issue #75: no more -f in cfn-init * gold plating the WordPress_2_Instances template * Wordpress 2 with EBS working * Resolving rpmlint errors and adding man pages * Register security group with launched instances * Fix creation of security group and rules * Fix a heap of pep8 errors * Make an attempt at passing exception messages from engine to cli * Fix 'heat describe' * Add a traceback on exception caught * Add a README to the templates directory to aid in navigation of the templates * Add a tools/heat-db-drop script for fatal error recovery * Make Wordpress_2_Instances.template work properly * Check errors better in resolve_attributes() * Add yum-plugin-fastestmirror on F17-x86_64 cfntools image * Add yum-plugin-fastestmirror to the cfntools images * Update WordPress_2_Instances.template to use cfntools and cfn-init * resources: remove insert_package_and_services * Properly launches a cfntools image with the appropriate userdata mime blob * Correct path to cfninit data * Yet more typos in cfntools template * Fix typo in template * Add a cfn-init call to cfntools * Automatic commit of package [heat] release [0.0.1-1] * Adding instructions on building the project with tito * Removing the PKG-INFO and vcsversion.py from the rpm * Initialized to use tito * Add unit test framework nose and associated helper scripts * Document all methods in the EngineManager class. These ones seem important * Updating the heat spec to pull in cloudinit files and i386 jeos templates * renaming CloudFormations to CloudFormation * Handle errors when listing events * Show stack description when status is unknown * Allow listing of all events * Use security groups in the multi-instance wp template * Fix listing stacks * Fix the stack.delete() by populating the resource id/state from the db * move the db stack delete into parser.py as it is non-blocking * Cleanup db imports (use heat code, don't import nova modules) * Consistently create the db resource entry * Add SecurityGroups to make is easier to use EIP * Eliminate overly-broad exception catching * Improvements to DB setup * Issue #52: Fix error in db-setup script * Start systemd services properly with cfn-init tool * Fix the jeos path when running from installed code * Delete extra white space * Fix 'heat list' when there are no stacks * Make jeos_create aware of existing disk files and previous glance registrations * Update F17 cfntools image to properly boot for cloudinit * Add ec2-user to F17 x86_64 tdl * add ec2-user to F16 cfntools image * Update i386 F16 cfntools image to match latest cloudinit features * updated F17 x86_64 cfntools tdl to new cloudinit model * Install cloudinit specific files that are loaded into the mime userdata * Updated x86_64 cfntools tdl to work with broken F16 repos and cloud-init * fixing small sed typo * Add elastic IP and userdata to 2-instance template * Fixing the heat events_list * Move the EIP settings into a different template * Initial ElasticIp work - not quite working * Add newly added tdls to manifest * Add 32-bit tdls for Fedora 16,17 jeos (gold and cfntools) * Fix exception getting events list * Import missing exceptions * Fix setting of admin role in keystone service * Resolving functional conflicts from merge * Adding new files to heat.spec file * Defaulting to the mysql db_backend, removing anydbm * Making delete stack work * Persisting resources * Made datetime objects JSON compatible by calling their to string functions * Integrating all stack, template, and event calls with database * Fix reporting of RemoteError exceptions from AMQP * Handle missing config file * Fix silly spello * Record the reason for any failures * Make better use of cloud-init * Make the create/delete non-blocking * Fix path to keystonerc * Rename cftools to cfntools in the wordpress single instance template * Put cfn-tools into the cfntool image * Renamed all occurrances of cftools to cfntools to be more consistent * Move cfntools to heat directory so they are accessible by jeos_create * Add 2-instance Wordpress template without EBS * Try harder to detach the server volume * Don't use the "depends_on" in resource.start * Cleanup some prints in the resources * Add a 2 instance wordpress example * Improve the ordering of stopping resources * Issue #54: Getting started with cfn-init * Get the volumes working properly * Add documentation for heat jeos_create function * typo fix in jeos_create * Fix "heat list" only showing empty list * Add utils & exception from openstack-common * Use local.py from openstack-common * Add F17 cftools TDL * Add F16 cftools tdl * Fix events_list * Fix describe and delete * Pass the parameters to the parser * Remove some more unused files * Don't need these files anymore. As per the layout in nova compute the manager is handling all the engine api calls * Fix --template-file * Use some evil to get the jeos tdl path * Fix stack_delete() * stack_db attributes seem broken. Comment these out for now and the API is generally working * Fix create a bit more * Hook up RPC methods * Pre-bake cftools into an image * Initial CloudFormations dummy files for vm helper tools * Revert "Allow templates specified from local filesystem" * Do mimimum to work with anydb * Add support for the Output section * Add an Outputs section to the template * run dos2unix on the templates * Updating the README to point to the Getting Started Wiki * Adding the sqlalchemy db implmentation * Allow templates specified from local filesystem * Updated openstack script to print a note about the default network * Beginings of Volumes and VolumeAttachments * Update readme with the Keystone service setup * Add a heat database to store templates, state, and events Fixes #39 * Make the "heat delete" command work * Fix a crash in "heat show/list" * Fix keystone creds in parser * Make wordpress template leave mysql+http running, and start/enable them by default * Pass the keystone creds to resource.py so usable from run-parser and heat * temporarily hack out the keystone auth * Updated wordpress single instance template to have quotes in proper place * F16 updates broken- Delete F16 and F17 update repos and don't yum update * Start userdata script after decoding * use << intead of << in Wordpress example * Add FnBase64 encoder, encode user data, and feed to nova userdata * Add installation of cloud-init to the JEOS creation operation * Show how to create a network after using the openstack tools script * Remove errant debugging print from run-parser.py * Update to setup directions * Stack list now communicating end to end. Time to hook some stuff up * Change default exchange to heat-engine from nova. Hook up 'list' though it doesn't work yet * Make create Working with recent glance mysql changes in F16/F17 RPMs * Add mysql db creation for glance * Fix run_parser.py to work with the db updates * Move simpledb to db/anydbm just so we are using the new API * Fix the service toke and endpoint * Add script to add heat service catalog into keystone * Get simple rpc.call working * Add needed strtime functions from nova * Add missing references * Wait for server to enter the ACTIVE state or ERROR state and send events * Stub out the database access API * s/image/heat in auth code * Copy some glance/common fixes * run_parser.py creates an instance now * Updated run-parser.py to work well with WordPress template * Updated README with more precise setup directions * Produce proper distro-arch variable for use with launching * Update run-parser to work with proper user parameters as sent through the apis * Security credentials are now passed into heat engine from cli * Fix spelling error dependancies->dependencies * Fix spelling error * Tidy up README.rst * Removing OpenStack LLC copyright * Adding F17 JEOS tdl Issue #25 * Fix some tabbing * Add the ValidateTemplate API * Fix misspelling of Ubuntu so tdl is properly found * Get the heat --parameters to work * Add ami conversion to OpenStack style architectures * Account for missing Properties * Install /var/lib/heat directory * Fix order of parmeters issue * Fix heat jeos_create F16 x86_64 litters files * Remove unneeded deps * Fix up some imports so they work. I think this is right now. :) * Add README to tools directory to help point out what files do * Initial work on migrating heat-engine to rpc * Add error checking and help to tool * Add a missing tab * Add code that shows how to create an instance * Consistently use Keystone auth from environment * Begin the change to a python only implementation * Add an experimental ssh monitoring script * Covert AWS instance types into Openstack Flavors * Change run_parser.py to run t1.micro rather then m1.large * Some glance keystone changes from getting started guide * Updated with latest F17 nova auth fix * install/erase working better * Add a openstack helper install script * Add elastic ip association to parser * A few cleanups and some comments. Nothing major * Use keystone auth environment variables * Improved "test" parser for python orchestration * Record events and retrieve them via "heat events_list " * tweak the templates so the defaults are actually what we want * Use full distro-arch as name of image registered with glance * Properly handle templates of invalid format * Display error message on invalid template URL * Display message on heat-api and heat-engine startup * Removed the *.log from the .gitignore so I can add the dummy files * Removing some of the cargo cult copy paste shrapnel * Adding rpm packaging for heat packages * teach jeos_create about the debug option * Improve the error checking in jeos_create * Updating template example github link * Minor text edits * Directives to not use variable names that conflict with pdb * Fix a module import failure * Fix README bullets * Fix README headings * Update the README * Start separating the api and the implementation * fix delete params (was treated as body) * Update readme with correct "raw" url for template * Remove erroneous setup operation * Install config files properly * Rename the etc/ files to what they need to be * Pretty up the README * Add etc to the manifest * Add a jeos create operation using oz * Updated README with install directions * Add MANIFEST.in and add a oz tdl for a F16 jeos * Sync cfg from openstack-common * Remove a bunch of unused util code * Add a cape event listener * Catch errors better when creating the stack * Remerge common code with glance * Add config cp to README doc * Don't crash if there is no "AWS::CloudFormation::Init" section * Move the default port number into common.config * Change the default port references to DEFAULT_PORT * Fix missing paren * Add a call to start cape process * Hook up the update and delete (not quite working) * Add a very rough-and-ready conversion from json to xml for cape * Add support for getting the template via url else we get RequestUriTooLong * Add missing RequestUriTooLong exception * Fix the systemd service section in the template * Add a disto mapping to get the image name * Simplify the template more * Add a simple single instance wordpress template * Remove openstack copy right assignment as we have not done that yet * Add a simple in-memory "db" so we can create/list stacks * Add setup.py and friends * Add simple readme * Fix Parameters * Initial commit (basics copied from glance) heat-2014.1/doc/0000775000175400017540000000000012323734470014432 5ustar jenkinsjenkins00000000000000heat-2014.1/doc/.gitignore0000664000175400017540000000001712323734123016413 0ustar jenkinsjenkins00000000000000target/ build/ heat-2014.1/doc/docbkx/0000775000175400017540000000000012323734470015704 5ustar jenkinsjenkins00000000000000heat-2014.1/doc/docbkx/heat-admin/0000775000175400017540000000000012323734470017713 5ustar jenkinsjenkins00000000000000heat-2014.1/doc/docbkx/heat-admin/ch_limitations.xml0000664000175400017540000000270012323734123023435 0ustar jenkinsjenkins00000000000000 GET'> PUT'> POST'> DELETE'> '> '> ]> Limitations TODO heat-2014.1/doc/docbkx/heat-admin/ch_using.xml0000664000175400017540000000267112323734123022235 0ustar jenkinsjenkins00000000000000 GET'> PUT'> POST'> DELETE'> '> '> ]> Using Heat TODO heat-2014.1/doc/docbkx/heat-admin/ch_install.xml0000664000175400017540000000106612323734123022553 0ustar jenkinsjenkins00000000000000 ]> Heat Installation This chapter describes how to install the Heat Service and get it up and running. heat-2014.1/doc/docbkx/heat-admin/ch_overview.xml0000664000175400017540000000422412323734123022752 0ustar jenkinsjenkins00000000000000 GET'> PUT'> POST'> DELETE'> '> '> powered by OpenStack'> powered by OpenStack'> ]> Overview This chapter describes the high-level concepts and components of a Heat deployment. heat-2014.1/doc/docbkx/heat-admin/app_core.xml0000664000175400017540000000074712323734123022230 0ustar jenkinsjenkins00000000000000 ]> Core Configuration File Options TODO heat-2014.1/doc/docbkx/heat-admin/pom.xml0000664000175400017540000001627612323734123021237 0ustar jenkinsjenkins00000000000000 4.0.0 org.openstack.docs openstack-guide 1.0.0-SNAPSHOT jar OpenStack Guides local 1 Rackspace Research Repositories true rackspace-research Rackspace Research Repository http://maven.research.rackspacecloud.com/content/groups/public/ rackspace-research Rackspace Research Repository http://maven.research.rackspacecloud.com/content/groups/public/ target/docbkx/pdf **/*.fo com.rackspace.cloud.api clouddocs-maven-plugin 1.12.2 goal1 generate-pdf generate-sources false 0 0 goal2 generate-webhelp generate-sources ${comments.enabled} 1 os-heat-guides 1 UA-17511903-1 appendix toc,title article/appendix nop article toc,title book title,figure,table,example,equation chapter toc,title part toc,title preface toc,title qandadiv toc qandaset toc reference toc,title set toc,title 0 0 true . bk-heat-admin-guide.xml http://docs.openstack.org/${release.path.name}/heat-admin/content/ reviewer openstack heat-2014.1/doc/docbkx/heat-admin/bk-heat-admin-guide.xml0000664000175400017540000000440612323734123024130 0ustar jenkinsjenkins00000000000000 ]> Heat Administration Guide 2012 OpenStack Grizzly (2013.1) Heat 2012-12-14 Copyright details are filled in by the template. This document is intended for administrators interested in running the Heat Service. 2012-12-14 First edition of this document. heat-2014.1/doc/docbkx/heat-admin/ch_preface.xml0000664000175400017540000000475012323734123022515 0ustar jenkinsjenkins00000000000000 GET'> PUT'> POST'> DELETE'> '> '> powered by OpenStack'> powered by OpenStack'> ]> Preface
Intended Audience TODO
Document Change History The most recent changes are described in the table below:
Resources TODO
heat-2014.1/doc/docbkx/README.rst0000664000175400017540000000100212323734123017357 0ustar jenkinsjenkins00000000000000================================ Building the user and admin docs ================================ This documentation should eventually end up in the OpenStack documentation repositories `api-site` and `openstack-manuals`. Dependencies ============ on Ubuntu: sudo apt-get install maven on Fedora Core: sudo yum install maven Use `mvn` ========= Build the REST API reference manual: cd api-ref mvn clean generate-sources Build the Heat admin guide: cd heat-admin mvn clean generate-sources heat-2014.1/doc/docbkx/api-ref/0000775000175400017540000000000012323734470017227 5ustar jenkinsjenkins00000000000000heat-2014.1/doc/docbkx/api-ref/src/0000775000175400017540000000000012323734470020016 5ustar jenkinsjenkins00000000000000heat-2014.1/doc/docbkx/api-ref/src/docbkx/0000775000175400017540000000000012323734470021270 5ustar jenkinsjenkins00000000000000heat-2014.1/doc/docbkx/api-ref/src/docbkx/api-ref.xml0000664000175400017540000005771712323734123023351 0ustar jenkinsjenkins00000000000000 GET'> PUT'> POST'> DELETE'> ]> OpenStack Orchestration API v1 Reference OpenStack LLC 2012 2013 OpenStack LLC API v1 OpenStack Orchestration 2013-10-03 Copyright details are filled in by the template. This document is intended for software developers interested in developing applications using the OpenStack Orchestration Application Programming Interface (API). 2013-10-03 Initial review. Overview OpenStack &Deployment; is a service to deploy and manage multiple composite cloud applications on OpenStack clouds. Interactions with OpenStack &Deployment; occur programmatically via the OpenStack &Deployment; API as described in this document. Reviewer: Can you provide me with a high-level Orchestration architecture diagram that I can add to this section? We welcome feedback, comments, and bug reports at https://bugs.launchpad.net/heat.
Intended Audience This Reference is intended to assist support teams, DevOps Engineers, and software developers who want to manage cloud applications with non-trivial architectures that leverage multiple OpenStack services. To use the information provided here, you should first have a general understanding of the &Deployment; service. You should also be familiar with: Other OpenStack services applicable to your cloud application architecture (Nova, Cinder, Neutron, and so forth) ReSTful web services JSON and/or YAML data serialization formats
Document Change History This version of the Reference replaces and obsoletes all previous versions. The most recent changes are described in the table below:
Additional Resources You can find information for developing templates in the Heat Orchestration Template (HOT) Specification at http://docs.openstack.org/developer/heat/template_guide/hot_spec.html#hot-spec. You can find example templates at https://github.com/heat-ci/heat-prod-templates/tree/master/example. For information about OpenStack services, refer to http://docs.openstack.org.
Concepts To use &Deployment; effectively, you should understand several key concepts:
Stack A stack is a group of resources (servers, load balancers, databases, and so forth) combined to fulfill a useful purpose. A stack is a set of resources that can be deployed. A stack contains a template and generates resources to run the application framework or component specified.
Resource A resource is a template artifact that represents some component of your desired architecture (a Nova server, a group of scaled servers, a Cinder volume, some configuration management system, and so forth).
Template An &Deployment; template is a portable file, written in a user-readable language, that describes how a set of resources should be assembled and what software should be installed in order to produce a working deployment. The template specifies what resources should be used, what attributes can be set, and other parameters that are critical to the successful, repeatable automation of a specific application deployment.
General API Information The &Deployment; API is implemented using a ReSTful web service interface. Like other OpenStack services, the &Deployment; Service shares a common token-based authentication system that allows seamless access between products and services.
Authentication The &Deployment; Service supports standard Keystone authentication. For more information, refer to the OpenStack Identity Service API v2.0 Reference. Please contact your provider for additional details on how to authenticate against this API.
Contract Version The contract version denotes the data model and behavior that the API supports. The current contract version is v1. The requested contract version is included in all request URLs. Different contract versions of the API may be available at any given time and are not guaranteed to be compatible with one another. Example Request URL (contract version in <emphasis role="strong" >bold</emphasis>) https://openstack.example.com/v1/1234 This document pertains to contract version 1.
Request/Response Types The &Deployment; API supports both the JSON and YAML data serialization formats. The request format is specified using the Content-Type header and is required for calls that have a request body. The response format can be specified in requests either by using the Accept header or by adding a .yaml or .json extension to the request URI. Note that it is possible for a response to be serialized using a format different from the request. If no response format is specified, JSON is the default. If conflicting formats are specified using both an Accept header and a query extension, the query extension takes precedence.
Response Formats
Format Accept Header Query Extension Default
JSON application/json .json Yes
YAML application/yaml .yaml No
Reviewer: need new examples below: one for "Request with Headers: JSON" and one for "Request with Headers: YAML". In the request example below, notice that Content-Type is set to application/json, but application/yaml is requested via the Accept header: Therefore a YAML response format is returned:
Date/Time Format The &Deployment; Service uses an ISO-8601 compliant date format for the display and consumption of date/time values. The system timezone is in UTC. MySQL converts TIMESTAMP values from the current time zone to UTC for storage, and back from UTC to the current time zone for retrieval. This does not occur for other types, such as DATETIME. &Deployment; Service Date/Time Format yyyy-MM-dd'T'HH:mm:ssZ See the table below for a description of the date/time format codes. May 19th, 2011 at 8:07:08 AM, GMT-5 would have the following format: 2011-05-19T08:07:08-05:00
Explanation of Date/Time Format Codes
Code Description
yyyy Four digit year
MM Two digit month
dd Two digit day of month
T Separator for date/time
HH Two digit hour of day (00-23)
mm Two digit minutes of hour
ss Two digit seconds of the minute
Z RFC-822 timezone
Faults The &Deployment; Service returns the following error codes: Error Code Description 400 Bad Request Invalid parameter values, un-parsable data, or missing required values. 404 Not Found The stack or resource cannot be found. 409 Conflict Invalid action is requested for the current stack status; more than one object exists for the specified non-unique identifier. 500 Internal Server Error Reverting the previously failed action encountered an error, an operation failed on one or more resources, an unexpected error occurred. Reviewer: Need new orchestration examples to replace the fault response examples below. The following two instanceFault examples show errors when the server has erred or cannot perform the requested operation: The error code (code) is returned in the body of the response for convenience. The message element returns a human-readable message that is appropriate for display to the end user. The details element is optional and may contain information that is useful for tracking down an error, such as a stack trace. The details element may or may not be appropriate for display to an end user, depending on the role and experience of the end user. The fault's root element (for example, instanceFault) may change depending on the type of error. The following two badRequest examples show errors when the volume size is invalid: The next two examples show itemNotFound errors:
Stack Status Stacks and resources have a state and a status as described in the lists that follow: State: INIT – (Resources only) The resource has not been provisioned. CREATE – The stack/resource is new. UPDATE – The stack/resource is changed. DELETE – The stack/resource is deleted. ROLLBACK – A previously failed change is being reverted. SUSPEND – (Stacks only) The stack is suspended. RESUME – (Stacks only) The stack is resumed. Status: IN-PROGRESS – The operation is in progress. COMPLETE – The operation is compete. FAILED – The operation failed. So, if you create a new stack and something goes wrong, your stack would be CREATE FAILED. One or more resources of that stack may be in the following states: INIT COMPLETE CREATE FAILED CREATE COMPLETE
API Operations This section describes the Orchestration API operations. Reviewer: please give me a list of section titles to use for dividing up the API calls into related sections. Reviewer: please give me the Error Response Codes for each of the API calls. Glossary resource A resource is a template artifact that represents some component of your desired architecture (a Nova server, a group of scaled servers, a Cinder volume, some configuration management system, and so forth). stack A stack is a group of resources (servers, load balancers, databases, and so forth) combined to fulfill a useful purpose. A stack is a set of resources that can be deployed. A stack contains a template and generates resources to run the application framework or component specified. template An &Deployment; template is a portable file, written in a user-readable language, that describes how a set of resources should be assembled and what software should be installed in order to produce a working deployment. The template specifies what resources should be used, what attributes can be set, and other parameters that are critical to the successful, repeatable automation of a specific application deployment. heat-2014.1/doc/docbkx/api-ref/src/wadls/0000775000175400017540000000000012323734470021130 5ustar jenkinsjenkins00000000000000heat-2014.1/doc/docbkx/api-ref/src/wadls/heat-api/0000775000175400017540000000000012323734470022620 5ustar jenkinsjenkins00000000000000heat-2014.1/doc/docbkx/api-ref/src/wadls/heat-api/src/0000775000175400017540000000000012323734470023407 5ustar jenkinsjenkins00000000000000heat-2014.1/doc/docbkx/api-ref/src/wadls/heat-api/src/README.rst0000664000175400017540000000053212323734123025071 0ustar jenkinsjenkins00000000000000========= HEAT wadl ========= The original heat wadl (heat-api-1.0.wadl) and the samples have now been deleted from this repository. The wadl has been renamed and migrated to the following repo location along with the samples: https://github.com/openstack/api-site/blob/master/api-ref/src/wadls/orchestration-api/src/v1/orchestration-api.wadl heat-2014.1/doc/docbkx/api-ref/pom.xml0000664000175400017540000001011312323734123020533 0ustar jenkinsjenkins00000000000000 4.0.0 org.openstack.identity docs 1.0 jar OpenStack API Page Project Rackspace Research Repositories true rackspace-research Rackspace Research Repository http://maven.research.rackspacecloud.com/content/groups/public/ rackspace-research Rackspace Research Repository http://maven.research.rackspacecloud.com/content/groups/public/ always UTF-8 1.12.2 com.rackspace.cloud.api clouddocs-maven-plugin ${doctools.version} g1 generate-webhelp generate-sources false 1 UA-17511903-1 true src/docbkx api-ref.xml reviewer openstack 2 true heat-2014.1/doc/README.rst0000664000175400017540000000135512323734123016120 0ustar jenkinsjenkins00000000000000=========================== Building the developer docs =========================== For user and admin docs, go to the directory `doc/docbkx`. Dependencies ============ You'll need to install python *Sphinx* package and *oslosphinx* package: :: sudo pip install sphinx oslosphinx If you are using the virtualenv you'll need to install them in the virtualenv. Get Help ======== Just type make to get help: :: make It will list available build targets. Build Doc ========= To build the man pages: :: make man To build the developer documentation as HTML: :: make html Type *make* for more formats. Test Doc ======== If you modify doc files, you can type: :: make doctest to check whether the format has problem. heat-2014.1/doc/Makefile0000664000175400017540000001267512323734123016100 0ustar jenkinsjenkins00000000000000# Makefile for Sphinx documentation # # You can set these variables from the command line. SPHINXOPTS = SPHINXBUILD = sphinx-build PAPER = BUILDDIR = build # Internal variables. PAPEROPT_a4 = -D latex_paper_size=a4 PAPEROPT_letter = -D latex_paper_size=letter ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) source # the i18n builder cannot share the environment and doctrees with the others I18NSPHINXOPTS = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) source .PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest gettext help: @echo "Please use \`make ' where is one of" @echo " html to make standalone HTML files" @echo " dirhtml to make HTML files named index.html in directories" @echo " singlehtml to make a single large HTML file" @echo " pickle to make pickle files" @echo " json to make JSON files" @echo " htmlhelp to make HTML files and a HTML help project" @echo " qthelp to make HTML files and a qthelp project" @echo " devhelp to make HTML files and a Devhelp project" @echo " epub to make an epub" @echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter" @echo " latexpdf to make LaTeX files and run them through pdflatex" @echo " text to make text files" @echo " man to make manual pages" @echo " texinfo to make Texinfo files" @echo " info to make Texinfo files and run them through makeinfo" @echo " gettext to make PO message catalogs" @echo " changes to make an overview of all changed/added/deprecated items" @echo " linkcheck to check all external links for integrity" @echo " doctest to run all doctests embedded in the documentation (if enabled)" clean: -rm -rf $(BUILDDIR)/* html: $(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/html." dirhtml: $(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml." singlehtml: $(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml @echo @echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml." pickle: $(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle @echo @echo "Build finished; now you can process the pickle files." json: $(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json @echo @echo "Build finished; now you can process the JSON files." htmlhelp: $(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp @echo @echo "Build finished; now you can run HTML Help Workshop with the" \ ".hhp project file in $(BUILDDIR)/htmlhelp." qthelp: $(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp @echo @echo "Build finished; now you can run "qcollectiongenerator" with the" \ ".qhcp project file in $(BUILDDIR)/qthelp, like this:" @echo "# qcollectiongenerator $(BUILDDIR)/qthelp/Heat.qhcp" @echo "To view the help file:" @echo "# assistant -collectionFile $(BUILDDIR)/qthelp/Heat.qhc" devhelp: $(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp @echo @echo "Build finished." @echo "To view the help file:" @echo "# mkdir -p $$HOME/.local/share/devhelp/Heat" @echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/Heat" @echo "# devhelp" epub: $(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub @echo @echo "Build finished. The epub file is in $(BUILDDIR)/epub." latex: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo @echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex." @echo "Run \`make' in that directory to run these through (pdf)latex" \ "(use \`make latexpdf' here to do that automatically)." latexpdf: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo "Running LaTeX files through pdflatex..." $(MAKE) -C $(BUILDDIR)/latex all-pdf @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex." text: $(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text @echo @echo "Build finished. The text files are in $(BUILDDIR)/text." man: $(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man @echo @echo "Build finished. The manual pages are in $(BUILDDIR)/man." texinfo: $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo @echo @echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo." @echo "Run \`make' in that directory to run these through makeinfo" \ "(use \`make info' here to do that automatically)." info: $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo @echo "Running Texinfo files through makeinfo..." make -C $(BUILDDIR)/texinfo info @echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo." gettext: $(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale @echo @echo "Build finished. The message catalogs are in $(BUILDDIR)/locale." changes: $(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes @echo @echo "The overview file is in $(BUILDDIR)/changes." linkcheck: $(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck @echo @echo "Link check complete; look for any errors in the above output " \ "or in $(BUILDDIR)/linkcheck/output.txt." doctest: $(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest @echo "Testing of doctests in the sources finished, look at the " \ "results in $(BUILDDIR)/doctest/output.txt." heat-2014.1/doc/source/0000775000175400017540000000000012323734470015732 5ustar jenkinsjenkins00000000000000heat-2014.1/doc/source/getting_started/0000775000175400017540000000000012323734470021121 5ustar jenkinsjenkins00000000000000heat-2014.1/doc/source/getting_started/jeos_building.rst0000664000175400017540000001530112323734123024463 0ustar jenkinsjenkins00000000000000.. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Building JEOS images for use with Heat ====================================== Heat's full functionality can only be used when launching cloud images that have the heat-cfntools_ package installed. This document describes some options for creating a heat-cfntools enabled image for yourself. .. _heat-cfntools: https://github.com/openstack/heat-cfntools Building an image with diskimage-builder ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ diskimage-builder_ is a tool for customizing cloud images. tripleo-image-elements_ is a collection of diskimage-builder elements related to the TripleO_ project. It includes an element for heat-cfntools which can be used to create heat-enabled images. .. _diskimage-builder: https://github.com/openstack/diskimage-builder .. _tripleo-image-elements: https://github.com/openstack/tripleo-image-elements .. _TripleO: https://wiki.openstack.org/wiki/TripleO Fetch the tool and elements:: git clone https://github.com/openstack/diskimage-builder.git git clone https://github.com/openstack/tripleo-image-elements.git To create a heat-cfntools enabled image with the current release of Fedora x86_64:: export ELEMENTS_PATH=tripleo-image-elements/elements diskimage-builder/bin/disk-image-create vm fedora heat-cfntools -a amd64 -o fedora-heat-cfntools The image may then be pushed to glance, e.g:: source ~/.openstack/keystonerc glance image-create --name fedora-heat-cfntools --is-public true --disk-format qcow2 --container-format bare < fedora-heat-cfntools.qcow2 To create a heat-cfntools enabled image with the current release of Ubuntu i386:: export ELEMENTS_PATH=tripleo-image-elements/elements diskimage-builder/bin/disk-image-create vm ubuntu heat-cfntools -a i386 -o ubuntu-heat-cfntools If you are creating your own images you should consider creating golden images which contain all the packages required for the stacks that you launch. You can do this by writing your own diskimage-builder elements and invoking those elements in the call to disk-image-create. This means that the resulting heat templates only need to modify configuration files. This will speed stack launch time and reduce the risk of a transient package download failure causing the stack launch to fail. Building an image with Oz ~~~~~~~~~~~~~~~~~~~~~~~~~ Another approach to building a heat-cfntools enabled image is to use Oz wrapped in a convenience script. The example below demonstrates how to build an F17 image, but there are Oz tdl templates for several other distributions provided in heat-templates/jeos Get heat-templates ------------------ Clone the heat-templates repository from GitHub at ``git://github.com/openstack/heat-templates.git`` Note Oz does not work in virt on virt situations. In this case, it is recommended that the prebuilt images are used. Download OS install DVD and copy it to libvirt images location -------------------------------------------------------------- :: sudo cp Downloads/Fedora-17-x86_64-DVD.iso /var/lib/libvirt/images Install Oz (RPM distros) ------------------------ We recommend cloning oz from the latest master. Support for building guests based on recent distributions is not available in the version of Oz shipped with many distros. On Fedora and other RPM-based distros:: git clone -q https://github.com/clalancette/oz.git pushd oz rm -f ~/rpmbuild/RPMS/noarch/oz-* make rpm sudo yum -q -y localinstall ~/rpmbuild/RPMS/noarch/oz-* popd Note: In the steps above, it's only necessary to be root for the yum localinstall, it's recommended not to be root while building the rpm. Install Oz (DEB distros) ------------------------ We recommend cloning oz from the latest master. The debian packaging is broken in older versions and support for building guests based on recent distributions is not available in the version of Oz shipped with many distros. On Fedora and other RPM-based distros: On Debian, Ubuntu and other deb based distros:: git clone https://github.com/clalancette/oz.git cd oz make deb cd .. sudo dpkg -i oz_*_all.deb sudo apt-get -f install Note: Select yes to "Create or update supermin appliance.". This will rebuild the guestfs appliance to work with latest updates of Ubuntu. Oz will not work properly without updating the guestfs appliance. Configure libguestfs (required by Oz) to work in latest Ubuntu 12 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Some files shipped with Ubuntu 12 are incompatible with libguestfs used by the image creation software Oz. To allow heat-jeos to work properly, run the following commands:: sudo chmod 644 /boot/vmlinuz* sudo update-guestfs-appliance Note: For more details see: http://permalink.gmane.org/gmane.comp.emulators.guestfs/1382 and http://libguestfs.org/guestfs-faq.1.html Note: If you want to create F17 images, you may need a new libguestfs binary of version 1.18.0 or later. Ubuntu Precise may not have this version yet. You can use the Debian Wheezy version including the `guestfs shared library`_, the tools_ and the `python libraries`_. .. _guestfs shared library: http://packages.debian.org/wheezy/amd64/libguestfs0/download .. _tools: http://packages.debian.org/wheezy/amd64/libguestfs-tools/download .. _python libraries: http://packages.debian.org/wheezy/amd64/python-guestfs/download Create a JEOS with heat-jeos.sh script -------------------------------------- heat-templates/tools contains a convenience wrapper for Oz which demonstrates how to create a JEOS:: cd heat-templates/tools sudo ./heat-jeos.sh ../jeos/F17-x86_64-cfntools.tdl F17-x86_64-cfntools Note: the second argument is the name as defined inside the TDL, so it may not necessarily match the filename Note: ``heat-jeos.sh`` must be run as root in order to create the disk image. Register the image with glance ------------------------------ On successful completion, the heat-jeos.sh script will generate a qcow2 image under /var/lib/libvirt/images/ The image may then be pushed to glance, e.g:: source ~/.openstack/keystonerc glance add name=F17-x86_64-cfntools is_public=true disk_format=qcow2 container_format=bare < /var/lib/libvirt/images/F17-x86_64-cfntools.qcow2 heat-2014.1/doc/source/getting_started/on_other.rst0000664000175400017540000000206612323734123023467 0ustar jenkinsjenkins00000000000000.. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Installing OpenStack on other Distributions =========================================== - There is a `Debian packaging team for OpenStack`_. - There are instructions for `installing OpenStack on Ubuntu`_. - Various other distributions may have packaging teams or Getting Started guides available. .. _Debian packaging team for OpenStack: http://wiki.openstack.org/Packaging/Debian .. _installing OpenStack on Ubuntu: http://docs.openstack.org/bexar/openstack-compute/admin/content/ch03s02.html heat-2014.1/doc/source/getting_started/on_fedora.rst0000664000175400017540000000364012323734123023605 0ustar jenkinsjenkins00000000000000.. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Getting Started With Heat on Fedora =================================== .. This file is a ReStructuredText document, but can be converted to a script using the accompanying rst2script.sed script. Any blocks that are indented by 4 spaces (including comment blocks) will appear in the script. To document code that should not appear in the script, use an indent of less than 4 spaces. (Using a Quoted instead of Indented Literal block also works.) To include code in the script that should not appear in the output, make it a comment block. Installing OpenStack and Heat on Fedora --------------------------------------- Either the Grizzly, or Havana release of OpenStack is required. If you are using Grizzly, you should use the stable/grizzly branch of Heat. Instructions for installing the RDO OpenStack distribution on Fedora are available at ``http://openstack.redhat.com/Quickstart`` Instructions for installing Heat on RDO are also available at ``http://openstack.redhat.com/Docs`` Alternatively, if you require a development environment not a package-based install, the suggested method is devstack, see instructions at :doc:`on_devstack` Example Templates ----------------- Check out the example templates at ``https://github.com/openstack/heat-templates``. Here you can view example templates which will work with several Fedora versions. heat-2014.1/doc/source/getting_started/index.rst0000664000175400017540000000134712323734123022762 0ustar jenkinsjenkins00000000000000.. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Getting Started Guides ====================== .. toctree:: :maxdepth: 2 on_devstack on_fedora on_ubuntu on_other jeos_building standalone heat-2014.1/doc/source/getting_started/on_ubuntu.rst0000664000175400017540000000173412323734123023671 0ustar jenkinsjenkins00000000000000.. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Getting Started With Heat on Ubuntu =================================== Heat is packaged for Debian, and Ubuntu (from 13.10) Alternatively, if you require a development environment not a package-based install, the suggested method is devstack, see instructions at :doc:`on_devstack` Example Templates ----------------- Check out the example templates at ``https://github.com/openstack/heat-templates``. heat-2014.1/doc/source/getting_started/on_devstack.rst0000664000175400017540000001103212323734123024143 0ustar jenkinsjenkins00000000000000.. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Heat and Devstack ================= Heat is fully integrated into DevStack. This is a convenient way to try out or develop heat alongside the current development state of all the other OpenStack projects. Heat on DevStack works on both Ubuntu and Fedora. These instructions assume you already have a working DevStack installation which can launch basic instances. Configure DevStack to enable Heat --------------------------------- Heat is configured by default on devstack for Icehouse or newer versions of OpenStack. It would also be useful to automatically download and register a VM image that Heat can launch. To do that add the following to your devstack `localrc`:: IMAGE_URLS+=",http://cloud.fedoraproject.org/fedora-20.x86_64.qcow2" URLs for any cloud image may be specified, but fedora images from F20 contain the heat-cfntools package which is required for some heat functionality. That is all the configuration that is required. When you run `./stack.sh` the Heat processes will be launched in `screen` with the labels prefixed with `h-`. Configure DevStack to enable Ceilometer (if using Alarms) --------------------------------------------------------- To use Ceilometer Alarms you need to enable Ceilometer in devstack. Adding the following lines to your `localrc` file will enable the ceilometer services:: CEILOMETER_BACKEND=mongo enable_service ceilometer-acompute ceilometer-acentral ceilometer-collector ceilometer-api enable_service ceilometer-alarm-notifier ceilometer-alarm-evaluator Confirming Heat is responding ----------------------------- Before any Heat commands can be run, the authentication environment needs to be loaded:: source openrc You can confirm that Heat is running and responding with this command:: heat stack-list This should return an empty line Preparing Nova for running stacks --------------------------------- Enabling Heat in devstack will replace the default Nova flavors with flavours that the Heat example templates expect. You can see what those flavors are by running:: nova flavor-list Heat needs to launch instances with a keypair, so we need to generate one:: nova keypair-add heat_key > heat_key.priv chmod 600 heat_key.priv Launching a stack ----------------- Now lets launch a stack, using an example template from the heat-templates repository:: heat stack-create teststack -u https://raw.github.com/openstack/heat-templates/master/cfn/F17/WordPress_Single_Instance.template -P "InstanceType=m1.large;DBUsername=wp;DBPassword=verybadpassword;KeyName=heat_key;LinuxDistribution=F17" Which will respond:: +--------------------------------------+-----------+--------------------+----------------------+ | ID | Name | Status | Created | +--------------------------------------+-----------+--------------------+----------------------+ | (uuid) | teststack | CREATE_IN_PROGRESS | (timestamp) | +--------------------------------------+-----------+--------------------+----------------------+ List stacks ~~~~~~~~~~~ List the stacks in your tenant:: heat stack-list List stack events ~~~~~~~~~~~~~~~~~ List the events related to a particular stack:: heat event-list teststack Describe the wordpress stack ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Show detailed state of a stack:: heat stack-show teststack Note: After a few seconds, the stack_status should change from IN_PROGRESS to CREATE_COMPLETE. Verify instance creation ~~~~~~~~~~~~~~~~~~~~~~~~ Because the software takes some time to install from the repository, it may be a few minutes before the Wordpress instance is in a running state. Point a web browser at the location given by the WebsiteURL Output as shown by heat stack-show teststack:: wget ${WebsiteURL} Delete the instance when done ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Note: The list operation will show no running stack.:: heat stack-delete teststack heat stack-list heat-2014.1/doc/source/getting_started/standalone.rst0000664000175400017540000000600012323734123023772 0ustar jenkinsjenkins00000000000000.. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. How to get Heat to work with a remote OpenStack. ================================================ Say you have a remote/public install of OpenStack and you want to use a local install of Heat to talk to it. This can be handy when developing, as the remote OpenStack can be kept stable and is not effected by changes made to the development machine. So lets say you have 2 machines: * “rock” ip == 192.168.1.88 (used for base OpenStack services) * “hack” ip == 192.168.1.77 (used for Heat development) Install your OpenStack as normal on “rock”. In this example "hack" is used as the devstack to install Heat on. The localrc looked like this:: HEAT_STANDALONE=True KEYSTONE_AUTH_HOST=192.168.1.88 KEYSTONE_AUTH_PORT=35357 KEYSTONE_AUTH_PROTOCOL=http KEYSTONE_SERVICE_HOST=$KEYSTONE_AUTH_HOST KEYSTONE_SERVICE_PORT=$KEYSTONE_AUTH_PORT KEYSTONE_SERVICE_PROTOCOL=$KEYSTONE_AUTH_PROTOCOL MY_PASSWORD=abetterpasswordthanthis DATABASE_PASSWORD=$MY_PASSWORD RABBIT_PASSWORD=$MY_PASSWORD disable_all_services ENABLED_SERVICES=qpid enable_service mysql heat h-api h-api-cfn h-api-cw h-eng Then run your ./stack.sh as normal. You then need a special environment (not devstack/openrc) to make this work. go to your “rock” machine and get the tenant_id that you want to work with:: keystone tenant-list +----------------------------------+--------------------+---------+ | id | name | enabled | +----------------------------------+--------------------+---------+ | 6943e3ebad0d465387d05d73f8e0b3fc | admin | True | | b12482712e354dd3b9f64ce608ba20f3 | alt_demo | True | | bf03bf32e3884d489004ac995ff7a61c | demo | True | | c23ceb3bf5dd4f9692488855de99137b | invisible_to_admin | True | | c328c1f3b945487d859ed2f53dcf0fe4 | service | True | +----------------------------------+--------------------+---------+ Let's say you want “demo”. Now make a file to store your new environment (heat.env). :: export HEAT_URL=http://192.168.1.77:8004/v1/bf03bf32e3884d489004ac995ff7a61c export OS_NO_CLIENT_AUTH=True export OS_USERNAME=admin export OS_TENANT_NAME=demo export OS_PASSWORD=abetterpasswordthanthis export OS_AUTH_URL=http://192.168.1.88:35357/v2.0/ Now you use this like:: . heat.env heat list Note: remember to open up firewall ports on “rock” so that you can access the OpenStack services. heat-2014.1/doc/source/glossary.rst0000664000175400017540000001513112323734123020323 0ustar jenkinsjenkins00000000000000.. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ========== Glossary ========== .. glossary:: :sorted: API server HTTP REST API service for heat. CFN An abbreviated form of "AWS CloudFormation". Constraint Defines valid input :term:`parameters` for a :term:`template`. Dependency When a :term:`resource` must wait for another resource to finish creation before being created itself. Heat adds an implicit dependency when a resource references another resource or one of its :term:`attributes `. An explicit dependency can also be created by the user in the template definition. Environment Used to affect the run-time behavior of the template. Provides a way to override the default resource implementation and parameters passed to Heat. See :ref:`Environments`. Heat Orchestration Template A particular :term:`template` format that is native to Heat. Heat Orchestration Templates are expressed in YAML and are not backwards-compatible with CloudFormation templates. HOT An acronym for ":term:`Heat Orchestration Template`". Input parameters See :term:`Parameters`. Metadata May refer to :term:`Resource Metadata`, :term:`Nova Instance metadata`, or the :term:`Metadata service`. Metadata service A Compute service that enables virtual machine instances to retrieve instance-specific data. See `Metadata service (OpenStack Cloud Admin Guide)`_. .. _Metadata service (OpenStack Cloud Admin Guide): http://docs.openstack.org/admin-guide-cloud/content/section_metadata-service.html Multi-region A feature of Heat that supports deployment to multiple regions. Nested resource A :term:`resource` instantiated as part of a :term:`nested stack`. Nested stack A :term:`template` referenced by URL inside of another template. Used to reduce redundant resource definitions and group complex architectures into logical groups. Nova Instance metadata User-provided *key:value* pairs associated with a Compute Instance. See `Instance specific data (OpenStack Compute Admin Guide)`_. .. _Instance specific data (OpenStack Compute Admin Guide): http://docs.openstack.org/grizzly/openstack-compute/admin/content/instance-data.html#inserting_metadata OpenStack Open source software for building private and public clouds. Orchestrate Arrange or direct the elements of a situation to produce a desired effect. Outputs A top-level block in a :term:`template` that defines what data will be returned by a stack after instantiation. Parameters A top-level block in a :term:`template` that defines what data can be passed to customise a template when it is used to create or update a :term:`stack`. Provider resource A :term:`resource` implemented by a :term:`provider template`. The parent resource's properties become the :term:`nested stack's ` parameters. See `What are "Providers"? (OpenStack Wiki)`_. .. _`What are "Providers"? (OpenStack Wiki)`: https://wiki.openstack.org/wiki/Heat/Providers#What_are_.22Providers.22.3F Provider template Allows user-definable :term:`resource providers ` to be specified via :term:`nested stacks `. The nested stack's :term:`outputs` become the parent stack's :term:`attributes `. Resource An element of OpenStack infrastructure instantiated from a particular :term:`resource provider`. See also :term:`Nested resource`. Resource attribute Data that can be obtained from a :term:`resource`, e.g. a server's public IP or name. Usually passed to another resource's :term:`properties ` or added to the stack's :term:`outputs`. Resource group A :term:`resource provider` that creates one or more identically configured :term:`resources ` or :term:`nested resources `. Resource Metadata A :term:`resource property` that contains CFN-style template metadata. See `AWS::CloudFormation::Init (AWS CloudFormation User Guide)`_ .. _AWS::CloudFormation::Init (AWS CloudFormation User Guide): http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-init.html Resource plugin Python code that understands how to instantiate and manage a :term:`resource`. See `Heat Resource Plugins (OpenStack wiki)`_. .. _Heat Resource Plugins (OpenStack wiki): https://wiki.openstack.org/wiki/Heat/Plugins#Heat_Resource_Plugins Resource property Data utilized for the instantiation of a :term:`resource`. Can be defined statically in a :term:`template` or passed in as :term:`input parameters `. Resource provider The implementation of a particular resource type. May be a :term:`Resource plugin` or a :term:`Provider template`. Stack A collection of instantiated :term:`resources ` that are defined in a single :term:`template`. Stack resource A :term:`resource provider` that allows the management of a :term:`nested stack` as a :term:`resource` in a parent stack. Template An orchestration document that details everything needed to carry out an :term:`orchestration `. Template resource See :term:`Provider resource`. User data A :term:`resource property` that contains a user-provided data blob. User data gets passed to `cloud-init`_ to automatically configure instances at boot time. See also `User data (OpenStack End User Guide)`_. .. _User data (OpenStack End User Guide): http://docs.openstack.org/user-guide/content/user-data.html#d6e2415 .. _cloud-init: https://help.ubuntu.com/community/CloudInit Wait condition A :term:`resource provider` that provides a way to communicate data or events from servers back to the orchestration engine. Most commonly used to pause the creation of the :term:`stack` while the server is being configured. heat-2014.1/doc/source/scale_deployment.rst0000664000175400017540000002647612323734123022025 0ustar jenkinsjenkins00000000000000.. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ==================== Scaling a Deployment ==================== When deploying in an environment where a large number of incoming requests need to be handled, the API and engine services can be overloaded. In those scenarios, in order to increase the system performance, it can be helpful to run multiple load-balanced APIs and engines. This guide details how to scale out the ReST API, the CFN API, and the engine, also known as the *heat-api*, *heat-api-cfn*, and *heat-engine* services, respectively. .. _scale_deployment_assumptions: Assumptions =========== This guide, using a devstack installation of OpenStack, assumes that: 1. You have configured devstack from `Single Machine Installation Guide `_; 2. You have set up Heat on devstack, as defined at `Heat and Devstack `_; 3. You have installed `HAProxy `_ on the devstack server. Architecture ============ This section shows the basic Heat architecture, the load balancing mechanism used and the target scaled out architecture. Basic Architecture ------------------ The Heat architecture is as defined at `Heat Architecture `_ and shown in the diagram below, where we have a CLI that sends HTTP requests to the ReST and CFN APIs, which in turn make calls using AMQP to the Heat engine. :: |- [REST API] -| [CLI] -- -- -- -- [ENGINE] |- [CFN API] -| Load Balancing -------------- As there is a need to use a load balancer mechanism between the multiple APIs and the CLI, a proxy has to be deployed. Because the Heat CLI and APIs communicate by exchanging HTTP requests and responses, a `HAProxy `_ HTTP load balancer server will be deployed between them. This way, the proxy will take the CLIs requests to the APIs and act on their behalf. Once the proxy receives a response, it will be redirected to the caller CLI. A round-robin distribution of messages from the AMQP queue will act as the load balancer for multiple engines. Check that your AMQP service is configured to distribute messages round-robin (RabbitMQ does this by default). Target Architecture ------------------- A scaled out Heat architecture is represented in the diagram below: :: |- [REST-API] -| |- ... -| |- [REST-API] -| |- [ENGINE] -| [CLI] -- -- [PROXY] -- -- -- |- ... -| |- [API-CFN] -| |- [ENGINE] -| |- ... -| |- [API-CFN] -| Thus, a request sent from the CLI looks like: 1. CLI contacts the proxy; 2. The HAProxy server, acting as a load balancer, redirects the call to an API instance; 3. The API server sends messages to the AMQP queue, and the engines pick up messages in round-robin fashion. Deploying Multiple APIs ======================= In order to run a Heat component separately, you have to execute one of the python scripts located at the *bin* directory of your Heat repository. These scripts take as argument a configuration file. When using devstack, the configuration file is located at */etc/heat/heat.conf*. For instance, to start new ReST and CFN API services, you must run: :: python bin/heat-api --config-file=/etc/heat/heat.conf python bin/heat-api-cfn --config-file=/etc/heat/heat.conf Each API service must have a unique address to listen. This address have to be defined in the configuration file. For ReST and CFN APIs, modify the *[heat_api]* and *[heat_api_cfn]* blocks, respectively. :: [heat_api] bind_port = {API_PORT} bind_host = {API_HOST} ... [heat_api_cfn] bind_port = {API_CFN_PORT} bind_host = {API_CFN_HOST} If you wish to run multiple API processes on the same machine, you must create multiple copies of the heat.conf file, each containing a unique port number. In addition, if you want to run some API services in different machines than the devstack server, you have to update the loopback addresses found at the *sql_connection* and *rabbit_host* properties to the devstack server's IP, which must be reachable from the remote machine. Deploying Multiple Engines ========================== All engines must be configured to use the same AMQP service. Ensure that all of the *rabbit_*\* and *kombu_*\* configuration options in the *[DEFAULT]* section of */etc/heat/heat.conf* match across each machine that will be running an engine. By using the same AMQP configuration, each engine will subscribe to the same AMQP *engine* queue and pick up work in round-robin fashion with the other engines. One or more engines can be deployed per host. Depending on the host's CPU architecture, it may be beneficial to deploy several engines on a single machine. To start multiple engines on the same machine, simply start multiple *heat-engine* processes: :: python bin/heat-engine --config-file=/etc/heat/heat.conf & python bin/heat-engine --config-file=/etc/heat/heat.conf & Deploying the Proxy =================== In order to simplify the deployment of the HAProxy server, we will replace the ReST and CFN APIs deployed when installing devstack by the HAProxy server. This way, there is no need to update, on the CLI, the addresses where it should look for the APIs. In this case, when it makes a call to any API, it will find the proxy, acting on their behalf. Note that the addresses that the HAProxy will be listening to are the pairs *API_HOST:API-PORT* and *API_CFN_HOST:API_CFN_PORT*, found at the *[heat_api]* and *[heat_api_cfn]* blocks on the devstack server's configuration file. In addition, the original *heat-api* and *heat-api-cfn* processes running in these ports have to be killed, because these addresses must be free to be used by the proxy. To deploy the HAProxy server on the devstack server, run *haproxy -f apis-proxy.conf*, where this configuration file looks like: :: global daemon maxconn 4000 defaults log global maxconn 8000 option redispatch retries 3 timeout http-request 10s timeout queue 1m timeout connect 10s timeout client 1m timeout server 1m timeout check 10s listen rest_api_proxy # The values required below are the original ones that were in # /etc/heat/heat.conf on the devstack server. bind {API_HOST}:{API_PORT} balance source option tcpka option httpchk # The values required below are the different addresses supplied when # running the ReST API instances. server SERVER_1 {HOST_1}:{PORT_1} ... server SERVER_N {HOST_N}:{PORT_N} listen cfn_api_proxy # The values required below are the original ones that were in # /etc/heat/heat.conf on the devstack server. bind {API_CFN_HOST}:{API_CFN_PORT} balance source option tcpka option httpchk # The values required below are the different addresses supplied when # running the CFN API instances. server SERVER_1 {HOST_1}:{PORT_1} ... server SERVER_N {HOST_N}:{PORT_N} Sample ====== This section aims to clarify some aspects of the scaling out solution, as well as to show more details of the configuration by describing a concrete sample. Architecture ------------ This section shows a basic OpenStack architecture and the target one that will be used for testing of the scaled-out heat services. Basic Architecture ^^^^^^^^^^^^^^^^^^ For this sample, consider that: 1. We have an architecture composed by 3 machines configured in a LAN, with the addresses A: 10.0.0.1; B: 10.0.0.2; and C: 10.0.0.3; 2. The OpenStack devstack installation, including the Heat module, has been done in the machine A, as shown in the :ref:`scale_deployment_assumptions` section. Target Architecture ^^^^^^^^^^^^^^^^^^^ At this moment, everything is running in a single devstack server. The next subsections show how to deploy a scaling out Heat architecture by: 1. Running one ReST and one CFN API on the machines B and C; 2. Setting up the HAProxy server on the machine A. Running the API and Engine Services ----------------------------------- For each machine, B and C, you must do the following steps: 1. Clone the Heat repository https://github.com/openstack/heat; 2. Create a local copy of the configuration file */etc/heat/heat.conf* from the machine A; 3. Make required changes on the configuration file; 4. Enter the Heat local repository and run: :: python bin/heat-api --config-file=/etc/heat/heat.conf python bin/heat-api-cfn --config-file=/etc/heat/heat.conf 5. Start as many *heat-engine* processes as you want running on that machine: :: python bin/heat-engine --config-file=/etc/heat/heat.conf & python bin/heat-engine --config-file=/etc/heat/heat.conf & ... Changes On Configuration ^^^^^^^^^^^^^^^^^^^^^^^^ The original file from A looks like: :: [DEFAULT] ... sql_connection = mysql://root:admin@127.0.0.1/heat?charset=utf8 rabbit_host = localhost ... [heat_api] bind_port = 8004 bind_host = 10.0.0.1 ... [heat_api_cfn] bind_port = 8000 bind_host = 10.0.0.1 After the changes for B, it looks like: :: [DEFAULT] ... sql_connection = mysql://root:admin@10.0.0.1/heat?charset=utf8 rabbit_host = 10.0.0.1 ... [heat_api] bind_port = 8004 bind_host = 10.0.0.2 ... [heat_api_cfn] bind_port = 8000 bind_host = 10.0.0.2 Setting Up HAProxy ------------------ On the machine A, kill the *heat-api* and *heat-api-cfn* processes by running *pkill heat-api* and *pkill heat-api-cfn*. After, run *haproxy -f apis-proxy.conf* with the following configuration: :: global daemon maxconn 4000 defaults log global maxconn 8000 option redispatch retries 3 timeout http-request 10s timeout queue 1m timeout connect 10s timeout client 1m timeout server 1m timeout check 10s listen rest_api_proxy bind 10.0.0.1:8004 balance source option tcpka option httpchk server rest-server-1 10.0.0.2:8004 server rest-server-2 10.0.0.3:8004 listen cfn_api_proxy bind 10.0.0.1:8000 balance source option tcpka option httpchk server cfn-server-1 10.0.0.2:8000 server cfn-server-2 10.0.0.3:8000 heat-2014.1/doc/source/architecture.rst0000664000175400017540000000701012323734123021137 0ustar jenkinsjenkins00000000000000.. Copyright 2011-2012 OpenStack Foundation All Rights Reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Heat Architecture ================= Heat is a service to orchestrate multiple composite cloud applications using the .. _AWS CloudFormation: http://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/Welcome.html?r=7078 template format, through both an OpenStack-native ReST API and a CloudFormation-compatible Query API. -------------------- Detailed Description -------------------- What is the purpose of the project and vision for it? *Heat provides an AWS CloudFormation implementation for OpenStack that orchestrates an AWS CloudFormation template describing a cloud application by executing appropriate OpenStack API calls to generate running cloud applications.* Describe the relevance of the project to other OpenStack projects and the OpenStack mission to provide a ubiquitous cloud computing platform: *The software integrates other core components of OpenStack into a one-file template system. The templates allow creation of most OpenStack resource types (such as instances, floating ips, volumes, security groups, users, etc), as well as some more advanced functionality such as instance high availability, instance autoscaling, and nested stacks. By providing very tight integration with other OpenStack core projects, all OpenStack core projects could receive a larger user base.* *Currently no other CloudFormation implementation exists for OpenStack. The developers believe cloud developers have a strong desire to move workloads from AWS to OpenStack deployments. Given the missing gap of a well-implemented and integrated CloudFormation API in OpenStack, we provide a high quality implementation of this gap improving the ubiquity of OpenStack.* ------------- Heat Services ------------- The developers are focused on creating an OpenStack style project using OpenStack design tenets, implemented in Python. We have started with full integration with Keystone. We have a number of components. As the developers have only started development in March 2012, the architecture is evolving rapidly. heat ---- The heat tool is a CLI which communicates with the heat-api to execute AWS CloudFormation APIs. End developers could also use the heat REST API directly. heat-api -------- The heat-api component provides an OpenStack-native REST API that processes API requests by sending them to the heat-engine over RPC. heat-api-cfn ------------ The heat-api-cfn component provides an AWS Query API that is compatible with AWS CloudFormation and processes API requests by sending them to the heat-engine over RPC. heat-engine ----------- The heat engine's main responsibility is to orchestrate the launching of templates and provide events back to the API consumer. The templates integrate well with .. _Puppet: https://s3.amazonaws.com/cloudformation-examples/IntegratingAWSCloudFormationWithPuppet.pdf and .. _Chef: http://www.full360.com/2011/02/27/integrating-aws-cloudformation-and-chef.html heat-2014.1/doc/source/ext/0000775000175400017540000000000012323734470016532 5ustar jenkinsjenkins00000000000000heat-2014.1/doc/source/ext/resources.py0000664000175400017540000002505212323734126021120 0ustar jenkinsjenkins00000000000000 # # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. # -*- coding: utf-8 -*- import itertools from heat.engine import environment from heat.engine import plugin_manager from heat.engine import resources from heat.engine import properties from heat.engine import support from heat.openstack.common.gettextutils import _ from docutils import nodes from sphinx.util.compat import Directive import pydoc global_env = environment.Environment({}, user_env=False) class resourcepages(nodes.General, nodes.Element): pass class ResourcePages(Directive): has_content = False required_arguments = 0 optional_arguments = 1 final_argument_whitespace = False option_spec = {} def run(self): prefix = self.arguments and self.arguments.pop() or None content = [] for resource_type, resource_class in _all_resources(prefix): self.resource_type = resource_type self.resource_class = resource_class section = self._section(content, resource_type, '%s') self.props_schemata = properties.schemata( self.resource_class.properties_schema) if resource_class.support_status.status == support.DEPRECATED: sstatus = resource_class.support_status.to_dict() para = nodes.inline( '', _('%(status)s - %(message)s') % sstatus) warning = nodes.note('', para) section.append(warning) cls_doc = pydoc.getdoc(resource_class) if cls_doc: para = nodes.paragraph('', cls_doc) section.append(para) self.contribute_properties(section) self.contribute_attributes(section) self.contribute_hot_syntax(section) self.contribute_yaml_syntax(section) self.contribute_json_syntax(section) return content def _section(self, parent, title, id_pattern): id = id_pattern % self.resource_type section = nodes.section(ids=[id]) parent.append(section) title = nodes.title('', title) section.append(title) return section def _prop_syntax_example(self, prop): if not prop: return 'Value' if prop.type == properties.Schema.LIST: schema = lambda i: prop.schema[i] if prop.schema else None sub_type = [self._prop_syntax_example(schema(i)) for i in range(2)] return '[%s, %s, ...]' % tuple(sub_type) elif prop.type == properties.Schema.MAP: def sub_props(): for sub_key, sub_value in prop.schema.items(): if sub_value.implemented: yield '"%s": %s' % ( sub_key, self._prop_syntax_example(sub_value)) return '{%s}' % (', '.join(sub_props()) if prop.schema else '...') else: return prop.type def contribute_hot_syntax(self, parent): section = self._section(parent, _('HOT Syntax'), '%s-hot') props = [] for prop_key in sorted(self.props_schemata.keys()): prop = self.props_schemata[prop_key] if (prop.implemented and prop.support_status.status == support.SUPPORTED): props.append('%s: %s' % (prop_key, self._prop_syntax_example(prop))) template = '''heat_template_version: 2013-05-23 ... resources: ... the_resource: type: %s properties: %s''' % (self.resource_type, '\n '.join(props)) block = nodes.literal_block('', template) section.append(block) def contribute_yaml_syntax(self, parent): section = self._section(parent, _('YAML Syntax'), '%s-yaml') props = [] for prop_key in sorted(self.props_schemata.keys()): prop = self.props_schemata[prop_key] if (prop.implemented and prop.support_status.status == support.SUPPORTED): props.append('%s: %s' % (prop_key, self._prop_syntax_example(prop))) template = '''HeatTemplateFormatVersion: '2012-12-12' ... Resources: ... TheResource: Type: %s Properties: %s''' % (self.resource_type, '\n '.join(props)) block = nodes.literal_block('', template) section.append(block) def contribute_json_syntax(self, parent): section = self._section(parent, _('JSON Syntax'), '%s-json') props = [] for prop_key in sorted(self.props_schemata.keys()): prop = self.props_schemata[prop_key] if (prop.implemented and prop.support_status.status == support.SUPPORTED): props.append('"%s": %s' % (prop_key, self._prop_syntax_example(prop))) template = '''{ "AWSTemplateFormatVersion" : "2010-09-09", ... "Resources" : { "TheResource": { "Type": "%s", "Properties": { %s } } } }''' % (self.resource_type, ',\n '.join(props)) block = nodes.literal_block('', template) section.append(block) @staticmethod def cmp_prop(x, y): x_key, x_prop = x y_key, y_prop = y if x_prop.support_status.status == y_prop.support_status.status: return cmp(x_key, y_key) if x_prop.support_status.status == support.SUPPORTED: return -1 if x_prop.support_status.status == support.DEPRECATED: return 1 return cmp(x_prop.support_status.status, y_prop.support_status.status) def contribute_property(self, prop_list, prop_key, prop): prop_item = nodes.definition_list_item( '', nodes.term('', prop_key)) prop_list.append(prop_item) prop_item.append(nodes.classifier('', prop.type)) definition = nodes.definition() prop_item.append(definition) if prop.support_status.status != support.SUPPORTED: para = nodes.inline( '', _('%(status)s - %(message)s') % prop.support_status.to_dict()) warning = nodes.note('', para) definition.append(warning) if not prop.implemented: para = nodes.inline('', _('Not implemented.')) warning = nodes.note('', para) definition.append(warning) return if prop.description: para = nodes.paragraph('', prop.description) definition.append(para) if prop.update_allowed: para = nodes.paragraph('', _('Can be updated without replacement.')) definition.append(para) else: para = nodes.paragraph('', _('Updates cause replacement.')) definition.append(para) if prop.required: para = nodes.paragraph('', _('Required property.')) elif prop.default is not None: para = nodes.paragraph( '', _('Optional property, defaults to "%s".') % prop.default) else: para = nodes.paragraph('', _('Optional property.')) definition.append(para) for constraint in prop.constraints: para = nodes.paragraph('', str(constraint)) definition.append(para) sub_schema = None if prop.schema and prop.type == properties.Schema.MAP: para = nodes.emphasis('', _('Map properties:')) definition.append(para) sub_schema = prop.schema elif prop.schema and prop.type == properties.Schema.LIST: para = nodes.emphasis( '', _('List contents:')) definition.append(para) sub_schema = prop.schema if sub_schema: sub_prop_list = nodes.definition_list() definition.append(sub_prop_list) for sub_prop_key, sub_prop in sorted(sub_schema.items(), self.cmp_prop): self.contribute_property( sub_prop_list, sub_prop_key, sub_prop) def contribute_properties(self, parent): if not self.props_schemata: return section = self._section(parent, _('Properties'), '%s-props') prop_list = nodes.definition_list() section.append(prop_list) for prop_key, prop in sorted(self.props_schemata.items(), self.cmp_prop): self.contribute_property(prop_list, prop_key, prop) def contribute_attributes(self, parent): schema = self.resource_class.attributes_schema if not schema: return section = self._section(parent, _('Attributes'), '%s-attrs') prop_list = nodes.definition_list() section.append(prop_list) for prop_key in sorted(schema.keys()): description = schema[prop_key] prop_item = nodes.definition_list_item( '', nodes.term('', prop_key)) prop_list.append(prop_item) definition = nodes.definition() prop_item.append(definition) if description: def_para = nodes.paragraph('', description) definition.append(def_para) def _all_resources(prefix=None): type_names = sorted(global_env.get_types()) if prefix is not None: def prefix_match(name): return name.startswith(prefix) type_names = itertools.ifilter(prefix_match, type_names) def resource_type(name): return name, global_env.get_class(name) return itertools.imap(resource_type, type_names) def _load_all_resources(): manager = plugin_manager.PluginManager('heat.engine.resources') resource_mapping = plugin_manager.PluginMapping('resource') res_plugin_mappings = resource_mapping.load_all(manager) resources._register_resources(global_env, res_plugin_mappings) environment.read_global_environment(global_env) def setup(app): _load_all_resources() app.add_node(resourcepages) app.add_directive('resourcepages', ResourcePages) heat-2014.1/doc/source/ext/__init__.py0000664000175400017540000000000012323734123020624 0ustar jenkinsjenkins00000000000000heat-2014.1/doc/source/conf.py0000664000175400017540000003672012323734123017234 0ustar jenkinsjenkins00000000000000# -*- coding: utf-8 -*- # # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. # # Heat documentation build configuration file, created by # sphinx-quickstart on Thu Dec 13 11:23:35 2012. # # This file is execfile()d with the current directory set to its containing # dir. # # Note that not all possible configuration values are present in this # autogenerated file. # # All configuration values have a default; values that are commented out # serve to show the default. import glob import os import re import sys import tempfile from oslo.config import cfg BASE_DIR = os.path.dirname(os.path.abspath(__file__)) ROOT = os.path.abspath(os.path.join(BASE_DIR, "..", "..")) CONTRIB_DIR = os.path.join(ROOT, 'contrib') PLUGIN_DIRS = glob.glob(os.path.join(CONTRIB_DIR, '*')) ENV_DIR = os.path.join(ROOT, "etc", "heat", "environment.d") TEMP_ENV_DIR = tempfile.mkdtemp() for f in glob.glob(os.path.join(ENV_DIR, "*.yaml")): with open(f, "r") as fin: name = os.path.split(f)[-1] with open(os.path.join(TEMP_ENV_DIR, name), "w") as fout: fout.write(fin.read().replace("file:///", "file://%s/" % ROOT)) sys.path.insert(0, ROOT) sys.path.insert(0, BASE_DIR) sys.path = PLUGIN_DIRS + sys.path cfg.CONF.import_opt('plugin_dirs', 'heat.common.config') cfg.CONF.set_override(name='plugin_dirs', override=PLUGIN_DIRS) cfg.CONF.import_opt('environment_dir', 'heat.common.config') cfg.CONF.set_override(name='environment_dir', override=TEMP_ENV_DIR) # This is required for ReadTheDocs.org, but isn't a bad idea anyway. os.environ['DJANGO_SETTINGS_MODULE'] = 'openstack_dashboard.settings' def write_autodoc_index(): def get_contrib_sources(): module_dirs = glob.glob(os.path.join(CONTRIB_DIR, '*')) module_names = map(os.path.basename, module_dirs) return dict( ('contrib/%s' % module_name, {'module': module_name, 'path': os.path.join(CONTRIB_DIR, module_name)} ) for module_name in module_names) def find_autodoc_modules(module_name, sourcedir): """Return a list of modules in the SOURCE directory.""" modlist = [] os.chdir(os.path.join(sourcedir, module_name)) print("SEARCHING %s" % sourcedir) for root, dirs, files in os.walk("."): for filename in files: if filename.endswith(".py"): # remove the pieces of the root elements = root.split(os.path.sep) # replace the leading "." with the module name elements[0] = module_name # and get the base module name base, extension = os.path.splitext(filename) if not (base == "__init__"): elements.append(base) result = ".".join(elements) modlist.append(result) return modlist RSTDIR = os.path.abspath(os.path.join(BASE_DIR, "sourcecode")) SRCS = {'heat': {'module': 'heat', 'path': ROOT}} SRCS.update(get_contrib_sources()) EXCLUDED_MODULES = ('heat.testing', 'heat.cmd', 'heat.common', 'heat.cloudinit', 'heat.cfn_client', 'heat.doc', 'heat.db', 'heat.engine.resources', 'heat.locale', 'heat.openstack', '.*\.tests', '.*\.resources') CURRENT_SOURCES = {} if not(os.path.exists(RSTDIR)): os.mkdir(RSTDIR) CURRENT_SOURCES[RSTDIR] = ['autoindex.rst', '.gitignore'] INDEXOUT = open(os.path.join(RSTDIR, "autoindex.rst"), "w") INDEXOUT.write("=================\n") INDEXOUT.write("Source Code Index\n") INDEXOUT.write("=================\n") for title, info in SRCS.items(): path = info['path'] modulename = info['module'] sys.stdout.write("Generating source documentation for %s\n" % title) INDEXOUT.write("\n%s\n" % title.capitalize()) INDEXOUT.write("%s\n" % ("=" * len(title),)) INDEXOUT.write(".. toctree::\n") INDEXOUT.write(" :maxdepth: 1\n") INDEXOUT.write("\n") MOD_DIR = os.path.join(RSTDIR, title) CURRENT_SOURCES[MOD_DIR] = [] if not(os.path.exists(MOD_DIR)): os.makedirs(MOD_DIR) for module in find_autodoc_modules(modulename, path): if any([re.match(exclude, module) for exclude in EXCLUDED_MODULES]): print("Excluded module %s." % module) continue mod_path = os.path.join(path, *module.split(".")) generated_file = os.path.join(MOD_DIR, "%s.rst" % module) INDEXOUT.write(" %s/%s\n" % (title, module)) # Find the __init__.py module if this is a directory if os.path.isdir(mod_path): source_file = ".".join((os.path.join(mod_path, "__init__"), "py",)) else: source_file = ".".join((os.path.join(mod_path), "py")) CURRENT_SOURCES[MOD_DIR].append("%s.rst" % module) # Only generate a new file if the source has changed or we don't # have a doc file to begin with. if not os.access(generated_file, os.F_OK) or \ os.stat(generated_file).st_mtime < \ os.stat(source_file).st_mtime: print("Module %s updated, generating new documentation." % module) FILEOUT = open(generated_file, "w") header = "The :mod:`%s` Module" % module FILEOUT.write("%s\n" % ("=" * len(header),)) FILEOUT.write("%s\n" % header) FILEOUT.write("%s\n" % ("=" * len(header),)) FILEOUT.write(".. automodule:: %s\n" % module) FILEOUT.write(" :members:\n") FILEOUT.write(" :undoc-members:\n") FILEOUT.write(" :show-inheritance:\n") FILEOUT.write(" :noindex:\n") FILEOUT.close() INDEXOUT.close() # Delete auto-generated .rst files for sources which no longer exist for directory, subdirs, files in list(os.walk(RSTDIR)): for old_file in files: if old_file not in CURRENT_SOURCES.get(directory, []): print("Removing outdated file for %s" % old_file) os.remove(os.path.join(directory, old_file)) write_autodoc_index() # If extensions (or modules to document with autodoc) are in another directory, # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. #sys.path.insert(0, os.path.abspath('.')) # -- General configuration ---------------------------------------------------- # If your documentation needs a minimal Sphinx version, state it here. #needs_sphinx = '1.0' # Add any Sphinx extension module names here, as strings. They can be # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom ones. extensions = ['sphinx.ext.autodoc', 'sphinx.ext.ifconfig', 'sphinx.ext.viewcode', 'sphinx.ext.todo', 'sphinx.ext.coverage', 'sphinx.ext.pngmath', 'sphinx.ext.viewcode', 'sphinx.ext.doctest', 'oslosphinx', 'ext.resources'] todo_include_todos = True # Add any paths that contain templates here, relative to this directory. if os.getenv('HUDSON_PUBLISH_DOCS'): templates_path = ['_ga', '_templates'] else: templates_path = ['_templates'] # The suffix of source filenames. source_suffix = '.rst' # The encoding of source files. #source_encoding = 'utf-8-sig' # The master toctree document. master_doc = 'index' # General information about the project. project = u'Heat' copyright = u'2012,2013 Heat Developers' # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. #language = None # There are two options for replacing |today|: either, you set today to some # non-false value, then it is used: #today = '' # Else, today_fmt is used as the format for a strftime call. #today_fmt = '%B %d, %Y' # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. exclude_patterns = ['**/#*', '**~', '**/#*#'] # The reST default role (used for this markup: `text`) # to use for all documents. #default_role = None # If true, '()' will be appended to :func: etc. cross-reference text. #add_function_parentheses = True # If true, the current module name will be prepended to all description # unit titles (such as .. function::). #add_module_names = True # If true, sectionauthor and moduleauthor directives will be shown in the # output. They are ignored by default. #show_authors = False # The name of the Pygments (syntax highlighting) style to use. pygments_style = 'sphinx' # A list of ignored prefixes for module index sorting. #modindex_common_prefix = [] primary_domain = 'py' nitpicky = False # -- Options for HTML output -------------------------------------------------- # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. # html_theme_path = ['.'] # html_theme = '_theme' # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the # documentation. html_theme_options = { "nosidebar": "false" } # Add any paths that contain custom themes here, relative to this directory. #html_theme_path = [] # The name for this set of Sphinx documents. If None, it defaults to # " v documentation". #html_title = None # A shorter title for the navigation bar. Default is the same as html_title. #html_short_title = None # The name of an image file (relative to this directory) to place at the top # of the sidebar. #html_logo = None # The name of an image file (within the static path) to use as favicon of the # docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 # pixels large. #html_favicon = None # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". # html_static_path = ['_static'] # If not '', a 'Last updated on:' timestamp is inserted at every page bottom, # using the given strftime format. #html_last_updated_fmt = '%b %d, %Y' git_cmd = "git log --pretty=format:'%ad, commit %h' --date=local -n1" html_last_updated_fmt = os.popen(git_cmd).read() # If true, SmartyPants will be used to convert quotes and dashes to # typographically correct entities. #html_use_smartypants = True # Custom sidebar templates, maps document names to template names. #html_sidebars = {} # Additional templates that should be rendered to pages, maps page names to # template names. #html_additional_pages = {} # If false, no module index is generated. #html_domain_indices = True # If false, no index is generated. #html_use_index = True # If true, the index is split into individual pages for each letter. #html_split_index = False # If true, links to the reST sources are added to the pages. #html_show_sourcelink = True # If true, "Created using Sphinx" is shown in the HTML footer. Default is True. #html_show_sphinx = True # If true, "(C) Copyright ..." is shown in the HTML footer. Default is True. #html_show_copyright = True # If true, an OpenSearch description file will be output, and all pages will # contain a tag referring to it. The value of this option must be the # base URL from which the finished HTML is served. #html_use_opensearch = '' # This is the file name suffix for HTML files (e.g. ".xhtml"). #html_file_suffix = None # Output file base name for HTML help builder. htmlhelp_basename = 'Heatdoc' # -- Options for LaTeX output ------------------------------------------------- latex_elements = { # The paper size ('letterpaper' or 'a4paper'). #'papersize': 'letterpaper', # The font size ('10pt', '11pt' or '12pt'). #'pointsize': '10pt', # Additional stuff for the LaTeX preamble. #'preamble': '', } # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, author, documentclass [howto/manual]) latex_documents = [ ('index', 'Heat.tex', u'Heat Documentation', u'Heat Developers', 'manual'), ] # The name of an image file (relative to this directory) to place at the top of # the title page. #latex_logo = None # For "manual" documents, if this is true, then toplevel headings are parts, # not chapters. #latex_use_parts = False # If true, show page references after internal links. #latex_show_pagerefs = False # If true, show URL addresses after external links. #latex_show_urls = False # Documents to append as an appendix to all manuals. #latex_appendices = [] # If false, no module index is generated. #latex_domain_indices = True # -- Options for manual page output ------------------------------------------- # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). man_pages = [ ('man/heat-api', 'heat-api', u'REST API service to the heat project.', [u'Heat Developers'], 1), ('man/heat-api-cfn', 'heat-api-cfn', u'CloudFormation compatible API service to the heat project.', [u'Heat Developers'], 1), ('man/heat-api-cloudwatch', 'heat-api-cloudwatch', u'CloudWatch alike API service to the heat project', [u'Heat Developers'], 1), ('man/heat-db-setup', 'heat-db-setup', u'Command line utility to setup the Heat database', [u'Heat Developers'], 1), ('man/heat-engine', 'heat-engine', u'Service which performs the actions from the API calls made by the user', [u'Heat Developers'], 1), ('man/heat-keystone-setup', 'heat-keystone-setup', u'Script which sets up keystone for usage by Heat', [u'Heat Developers'], 1), ('man/heat-manage', 'heat-manage', u'Script which helps manage specific database operations', [u'Heat Developers'], 1), ] # If true, show URL addresses after external links. #man_show_urls = False # -- Options for Texinfo output ----------------------------------------------- # Grouping the document tree into Texinfo files. List of tuples # (source start file, target name, title, author, # dir menu entry, description, category) texinfo_documents = [ ('index', 'Heat', u'Heat Documentation', u'Heat Developers', 'Heat', 'One line description of project.', 'Miscellaneous'), ] # Documents to append as an appendix to all manuals. #texinfo_appendices = [] # If false, no module index is generated. #texinfo_domain_indices = True # How to display URL addresses: 'footnote', 'no', or 'inline'. #texinfo_show_urls = 'footnote' heat-2014.1/doc/source/index.rst0000664000175400017540000000527112323734126017576 0ustar jenkinsjenkins00000000000000.. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ================================================== Welcome to the Heat developer documentation! ================================================== Heat is a service to :term:`orchestrate` multiple composite cloud applications using the AWS CloudFormation template format, through both an OpenStack-native ReST API and a CloudFormation-compatible Query API. What is the purpose of the project and vision for it? ===================================================== * Heat provides a template based orchestration for describing a cloud application by executing appropriate :term:`OpenStack` API calls to generate running cloud applications. * The software integrates other core components of OpenStack into a one-file template system. The templates allow creation of most OpenStack resource types (such as instances, floating ips, volumes, security groups, users, etc), as well as some more advanced functionality such as instance high availability, instance autoscaling, and nested stacks. By providing very tight integration with other OpenStack core projects, all OpenStack core projects could receive a larger user base. * Allow deployers to integrate with Heat directly or by adding custom plugins. This documentation offers information on how heat works and how to contribute to the project. Getting Started =============== .. toctree:: :maxdepth: 1 getting_started/index templates/index template_guide/index glossary Man Pages ========= .. toctree:: :maxdepth: 2 man/index Developers Documentation ======================== .. toctree:: :maxdepth: 1 architecture API Documentation ======================== - `Heat REST API Reference (OpenStack API Complete Reference - Orchestration)`_ .. _`Heat REST API Reference (OpenStack API Complete Reference - Orchestration)`: http://api.openstack.org/api-ref-orchestration.html Operations Documentation ======================== .. toctree:: :maxdepth: 1 scale_deployment Code Documentation ================== .. toctree:: :maxdepth: 3 sourcecode/autoindex Indices and tables ================== * :ref:`genindex` * :ref:`modindex` * :ref:`search` heat-2014.1/doc/source/templates/0000775000175400017540000000000012323734470017730 5ustar jenkinsjenkins00000000000000heat-2014.1/doc/source/templates/hot/0000775000175400017540000000000012323734470020522 5ustar jenkinsjenkins00000000000000heat-2014.1/doc/source/templates/hot/hello_world.rst0000664000175400017540000000225412323734123023564 0ustar jenkinsjenkins00000000000000.. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Template -------- _https://github.com/openstack/heat-templates/blob/master/hot/hello_world.yaml Description ----------- Hello world HOT template that just defines a single compute instance. Contains just base features to verify base HOT support. Parameters ---------- *KeyName* :mod:`(required)` *type* *string* *description* *Name* of an existing key pair to use for the instance *InstanceType* :mod:`(required)` *type* *string* *description* *Instance type* for the instance to be created *ImageId* :mod:`(required)` *type* *string* *description* *ID* of the image to use for the instance heat-2014.1/doc/source/templates/cfn/0000775000175400017540000000000012323734470020476 5ustar jenkinsjenkins00000000000000heat-2014.1/doc/source/templates/cfn/WordPress_Single_Instance.rst0000664000175400017540000000333012323734123026277 0ustar jenkinsjenkins00000000000000.. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Template -------- _https://github.com/openstack/heat-templates/blob/master/cfn/WordPress_Single_Instance.template Description ----------- AWS CloudFormation Sample Template WordPress_Single_Instance: WordPress is web software you can use to create a beautiful website or blog. This template installs a single-instance WordPress deployment using a local MySQL database to store the data. Parameters ---------- *KeyName* :mod:`(required)` *type* *string* *description* *Name* of an existing key pair to use for the instance *InstanceType* :mod:`(optional)` *type* *string* *description* *Instance type* for the instance to be created *DBName* :mod:`(optional)` *type* *string* *description* *The WordPress database name* *DBUsernameName* :mod:`(optional)` *type* *string* *description* *The WordPress database admin account username* *DBPassword* :mod:`(optional)` *type* *string* *description* *The WordPress database admin account password* *DBRootPassword* :mod:`(optional)` *type* *string* *description* *Root password for MySQL* *LinuxDistribution* :mod:`(optional)` *type* *string* *description* *Distribution of choice* heat-2014.1/doc/source/templates/index.rst0000664000175400017540000000150012323734123021560 0ustar jenkinsjenkins00000000000000.. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. This page documents the templates at _https://github.com/openstack/heat-templates/ HOT Templates ============= .. toctree:: :maxdepth: 1 hot/hello_world CFN Templates ============= .. toctree:: :maxdepth: 1 cfn/WordPress_Single_Instanceheat-2014.1/doc/source/man/0000775000175400017540000000000012323734470016505 5ustar jenkinsjenkins00000000000000heat-2014.1/doc/source/man/heat-api-cfn.rst0000664000175400017540000000167612323734123021500 0ustar jenkinsjenkins00000000000000============ heat-api-cfn ============ .. program:: heat-api-cfn SYNOPSIS ======== ``heat-api-cfn [options]`` DESCRIPTION =========== heat-api-cfn is a CloudFormation compatible API service to the heat project. INVENTORY ========= heat-api-cfn is a service that exposes an external REST based api to the heat-engine service. The communication between the heat-api-cfn and heat-engine uses message queue based RPC. OPTIONS ======= .. cmdoption:: --config-file Path to a config file to use. Multiple config files can be specified, with values in later files taking precedence. .. cmdoption:: --config-dir Path to a config directory to pull .conf files from. This file set is sorted, so as to provide a predictable parse order if individual options are over-ridden. The set is parsed after the file(s), if any, specified via --config-file, hence over-ridden options in the directory take precedence. FILES ======== * /etc/heat/heat.conf heat-2014.1/doc/source/man/heat-api.rst0000664000175400017540000000162112323734123020722 0ustar jenkinsjenkins00000000000000======== heat-api ======== .. program:: heat-api SYNOPSIS ======== ``heat-api [options]`` DESCRIPTION =========== heat-api provides an external REST API to the heat project. INVENTORY ========= heat-api is a service that exposes an external REST based api to the heat-engine service. The communication between the heat-api and heat-engine uses message queue based RPC. OPTIONS ======= .. cmdoption:: --config-file Path to a config file to use. Multiple config files can be specified, with values in later files taking precedence. .. cmdoption:: --config-dir Path to a config directory to pull .conf files from. This file set is sorted, so as to provide a predictable parse order if individual options are over-ridden. The set is parsed after the file(s), if any, specified via --config-file, hence over-ridden options in the directory take precedence. FILES ======== * /etc/heat/heat.conf heat-2014.1/doc/source/man/heat-manage.rst0000664000175400017540000000211612323734123021401 0ustar jenkinsjenkins00000000000000=========== heat-manage =========== .. program:: heat-manage SYNOPSIS ======== ``heat-manage [options]`` DESCRIPTION =========== heat-manage helps manage heat specific database operations. OPTIONS ======= The standard pattern for executing a heat-manage command is: ``heat-manage []`` Run with -h to see a list of available commands: ``heat-manage -h`` Commands are db_version, db_sync and purge_deleted. Detailed descriptions are below. Heat Db version ~~~~~~~~~~~~~~~ ``heat-manage db_version`` Print out the db schema revision. ``heat-manage db_sync`` Sync the database up to the most recent version. ``heat-manage purge_deleted [-g {days,hours,minutes,seconds}] [age]`` Purge db entries marked as deleted and older than [age]. FILES ===== The /etc/heat/heat.conf file contains global options which can be used to configure some aspects of heat-manage, for example the DB connection and logging. BUGS ==== * Heat issues are tracked in Launchpad so you can view or report bugs here `OpenStack Heat Bugs `__ heat-2014.1/doc/source/man/heat-db-setup.rst0000664000175400017540000000311512323734123021674 0ustar jenkinsjenkins00000000000000============= heat-db-setup ============= .. program:: heat-db-setup SYNOPSIS ======== ``heat-db-setup [COMMANDS] [OPTIONS]`` DESCRIPTION =========== heat-db-setup is a tool which configures the local MySQL database for heat. Typically distro-specific tools would provide this functionality so please read the distro-specific documentation for configuring Heat. COMMANDS ======== ``rpm`` Indicate the distribution is a RPM packaging based distribution. ``deb`` Indicate the distribution is a DEB packaging based distribution. OPTIONS ======= .. cmdoption:: -h, --help Print usage information. .. cmdoption:: -p, --password Specify the password for the 'heat' MySQL user that the script will use to connect to the 'heat' MySQL database. By default, the password 'heat' will be used. .. cmdoption:: -r, --rootpw Specify the root MySQL password. If the script installs the MySQL server, it will set the root password to this value instead of prompting for a password. If the MySQL server is already installed, this password will be used to connect to the database instead of having to prompt for it. .. cmdoption:: -y, --yes In cases where the script would normally ask for confirmation before doing something, such as installing mysql-server, just assume yes. This is useful if you want to run the script non-interactively. EXAMPLES ======== heat-db-setup rpm -p heat_password -r mysql_pwd -y heat-db-setup deb -p heat_password -r mysql_pwd -y heat-db-setup rpm BUGS ==== Heat bugs are managed through Launchpad `OpenStack Heat Bugs `__ heat-2014.1/doc/source/man/heat-engine.rst0000664000175400017540000000156512323734123021425 0ustar jenkinsjenkins00000000000000=========== heat-engine =========== .. program:: heat-engine SYNOPSIS ======== ``heat-engine [options]`` DESCRIPTION =========== Heat is the heat project server with an internal api called by the heat-api. INVENTORY ========= The heat engine does all the orchestration work and is the layer in which the resource integration is implemented. OPTIONS ======= .. cmdoption:: --config-file Path to a config file to use. Multiple config files can be specified, with values in later files taking precedence. .. cmdoption:: --config-dir Path to a config directory to pull .conf files from. This file set is sorted, so as to provide a predictable parse order if individual options are over-ridden. The set is parsed after the file(s), if any, specified via --config-file, hence over-ridden options in the directory take precedence. FILES ======== * /etc/heat/heat.conf heat-2014.1/doc/source/man/index.rst0000664000175400017540000000057712323734123020352 0ustar jenkinsjenkins00000000000000==================================== Man pages for services and utilities ==================================== ------------- Heat services ------------- .. toctree:: :maxdepth: 2 heat-engine heat-api heat-api-cfn heat-api-cloudwatch -------------- Heat utilities -------------- .. toctree:: :maxdepth: 2 heat-manage heat-db-setup heat-keystone-setup heat-2014.1/doc/source/man/heat-api-cloudwatch.rst0000664000175400017540000000142212323734123023054 0ustar jenkinsjenkins00000000000000=================== heat-api-cloudwatch =================== .. program:: heat-api-cloudwatch SYNOPSIS ======== ``heat-api-cloudwatch [options]`` DESCRIPTION =========== heat-api-cloudwatch is a CloudWatch-like API service to the heat project. OPTIONS ======= .. cmdoption:: --config-file Path to a config file to use. Multiple config files can be specified, with values in later files taking precedence. .. cmdoption:: --config-dir Path to a config directory to pull .conf files from. This file set is sorted, so as to provide a predictable parse order if individual options are over-ridden. The set is parsed after the file(s), if any, specified via --config-file, hence over-ridden options in the directory take precedence. FILES ======== * /etc/heat/heat.conf heat-2014.1/doc/source/man/heat-keystone-setup.rst0000664000175400017540000000116112323734123023147 0ustar jenkinsjenkins00000000000000=================== heat-keystone-setup =================== .. program:: heat-keystone-setup SYNOPSIS ======== ``heat-keystone-setup`` DESCRIPTION =========== The heat-keystone-setup tool configures keystone for use with Heat. This script requires admin keystone credentials to be available in the shell environment and write access to /etc/keystone. Distributions may provide other tools to setup keystone for use with Heat, so check the distro documentation first. EXAMPLES ======== heat-keystone-setup BUGS ==== Heat bugs are managed through Launchpad `OpenStack Heat Bugs `__ heat-2014.1/doc/source/template_guide/0000775000175400017540000000000012323734470020722 5ustar jenkinsjenkins00000000000000heat-2014.1/doc/source/template_guide/environment.rst0000664000175400017540000000507312323734126024023 0ustar jenkinsjenkins00000000000000.. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. .. _environments: ============ Environments ============ The environment is used to affect the runtime behaviour of the template. It provides a way to override the default resource implementation and the parameters passed to Heat. ------ Format ------ It is a yaml text file with two main sections "resource_registry" and "parameters". ------------------ Command line usage ------------------ :: heat stack-create my_stack -e my_env.yaml -P "some_parm=bla" -f my_tmpl.yaml If you do not like the option "-e my_env.yaml", you can put file my_env.yaml in "/etc/heat/environment.d/" and restart heat engine. Then, you can use the heat client as in the example below: :: heat stack-create my_stack -P "some_parm=bla" -f my_tmpl.yaml -------------- Usage examples -------------- 1) Pass parameters into Heat ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :: parameters: KeyName: heat_key InstanceType: m1.micro ImageId: F18-x86_64-cfntools 2) Deal with the mapping of Quantum to Neutron ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :: resource_registry: "OS::Quantum*": "OS::Neutron*" So all existing resources which can be matched with "OS::Neutron*" will be mapped to "OS::Quantum*" accordingly. 3) Override a resource type with a custom template resource ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :: resource_registry: "AWS::EC2::Instance": file:///home/mine/my_instance_with_better_defaults.yaml Please note that the template resource URL here must end with ".yaml" or ".template", or it will not be treated as a custom template resource. 4) Always map resource type X to Y ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :: resource_registry: "OS::Networking::FloatingIP": "OS::Nova::FloatingIP" 5) Use default resources except one for a particular resource in the template ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :: resource_registry: resources: my_db_server: "OS::DBInstance": file:///home/mine/all_my_cool_templates/db.yaml heat-2014.1/doc/source/template_guide/contrib.rst0000664000175400017540000000317112323734123023111 0ustar jenkinsjenkins00000000000000.. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Rackspace Cloud Resource Types ------------------------------ .. rubric:: These resources are not enabled by default. The resources in this module are for using Heat with the Rackspace Cloud. These resources either allow using Rackspace services that don't have equivalent services in OpenStack or account for differences between a generic Openstack deployment and the Rackspace Cloud. Rackspace resources depend on the dev branch of `pyrax `_ to work properly. More information about them can be found in the `README `_. .. resourcepages:: Rackspace:: DockerInc Resource ------------------ .. rubric:: This resource is not enabled by default. This plugin enables the use of Docker containers in a Heat template and requires the `docker-py `_ package. You can find more information in the `README `_. .. resourcepages:: DockerInc:: heat-2014.1/doc/source/template_guide/functions.rst0000664000175400017540000001364112323734123023464 0ustar jenkinsjenkins00000000000000.. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ================== Built in functions ================== There are a number of functions that you can use to help you write templates. All of these functions (except *Ref*) start with *Fn::*. --- Ref --- Return the value of the named parameter or Resource. Parameters ~~~~~~~~~~ name : String The name of the Resource or Parameter. Usage ~~~~~ :: {Ref: my_server} Returns the nova instance ID. For example, ``d8093de0-850f-4513-b202-7979de6c0d55`` ---------- Fn::Base64 ---------- This returns the Base64 representation of the input string. Parameters ~~~~~~~~~~ value : String The string to convert. Usage ~~~~~ :: {Base64: "convert this string please."} Returns the Base64 of the input string. ------------- Fn::FindInMap ------------- Returns the value corresponding to keys into a two-level map declared in the Mappings section. Parameters ~~~~~~~~~~ map_name : String The logical name of a mapping declared in the Mappings section that contains the keys and values. top_level_key : String The top-level key name. It's value is a list of key-value pairs. second_level_key : String The second-level key name, which is set to one of the keys from the list assigned to top_level_key. Usage ~~~~~ :: Mapping: MyContacts: jone: {phone: 337, email: a@b.com} jim: {phone: 908, email: g@b.com} {"Fn::FindInMap": ["MyContacts", "jim", "phone" ] } Returns ``908`` ---------- Fn::GetAtt ---------- Returns an attribute of a Resource within the template. Parameters ~~~~~~~~~~ resource : String The name of the Resource. attribute : String The name of the attribute. Usage ~~~~~ :: {Fn::GetAtt: [my_server, PublicIp]} Returns an IP address such as ``10.0.0.2`` ---------- Fn::GetAZs ---------- Return the Availability Zones within the given region. *Note: AZ's and regions are not fully implemented in Heat.* Parameters ~~~~~~~~~~ region : String The name of the region. Usage ~~~~~ :: {Fn::GetAZs: ""} Returns the list provided by ``nova availability-zone-list`` -------- Fn::Join -------- Like python join, it joins a list of strings with the given delimiter. Parameters ~~~~~~~~~~ delimiter : String The string to join the list with. list : list The list to join. Usage ~~~~~ :: {Fn::Join: [",", ["beer", "wine", "more beer"]]} Returns ``beer, wine, more beer`` ---------- Fn::Select ---------- Select an item from a list. *Heat extension: Select an item from a map* Parameters ~~~~~~~~~~ selector : string or integer The number of item in the list or the name of the item in the map. collection : map or list The collection to select the item from. Usage ~~~~~ For a list lookup: :: { "Fn::Select" : [ "2", [ "apples", "grapes", "mangoes" ] ] } Returns ``mangoes`` For a map lookup: :: { "Fn::Select" : [ "red", {"red": "a", "flu": "b"} ] } Returns ``a`` --------- Fn::Split --------- This is the reverse of Join. Convert a string into a list based on the delimiter. Parameters ~~~~~~~~~~ delimiter : string Matching string to split on. string : String The string to split. Usage ~~~~~ :: { "Fn::Split" : [ ",", "str1,str2,str3,str4"]} Returns ``{["str1", "str2", "str3", "str4"]}`` ----------- Fn::Replace ----------- Find an replace one string with another. Parameters ~~~~~~~~~~ subsitutions : map A map of subsitutions. string: String The string to do the substitutions in. Usage ~~~~~ :: {"Fn::Replace": [ {'$var1': 'foo', '%var2%': 'bar'}, '$var1 is %var2%' ]} returns "foo is bar" ------------------ Fn::ResourceFacade ------------------ When writing a Template Resource: - user writes a template that will fill in for a resource (the resource is the facade). - when they are writing their template they need to access the metadata from the facade. Parameters ~~~~~~~~~~ attribute_name : String One of ``Metadata``, ``DeletionPolicy`` or ``UpdatePolicy``. Usage ~~~~~ :: {'Fn::ResourceFacade': 'Metadata'} {'Fn::ResourceFacade': 'DeletionPolicy'} {'Fn::ResourceFacade': 'UpdatePolicy'} Example ~~~~~~~ Here is a top level template ``top.yaml`` :: resources: my_server: type: OS::Nova::Server metadata: key: value some: more stuff Here is a resource template ``my_actual_server.yaml`` :: resources: _actual_server_: type: OS::Nova::Server metadata: {'Fn::ResourceFacade': Metadata} The environment file ``env.yaml`` :: resource_registry: resources: my_server: "OS::Nova::Server": my_actual_server.yaml To use it :: heat stack-create -f top.yaml -e env.yaml What happened is the metadata in ``top.yaml`` (key: value, some: more stuff) gets passed into the resource template via the `Fn::ResourceFacade`_ function. ------------------- Fn::MemberListToMap ------------------- Convert an AWS style member list into a map. Parameters ~~~~~~~~~~ key name: string The name of the key (normally "Name" or "Key") value name: string The name of the value (normally "Value") list: A list of strings The string to convert. Usage ~~~~~ :: {'Fn::MemberListToMap': ['Name', 'Value', ['.member.0.Name=key', '.member.0.Value=door', '.member.1.Name=colour', '.member.1.Value=green']]} returns {'key': 'door', 'colour': 'green'} heat-2014.1/doc/source/template_guide/hot_guide.rst0000664000175400017540000002056112323734123023422 0ustar jenkinsjenkins00000000000000.. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. .. _hot_guide: ======================================= Heat Orchestration Template (HOT) Guide ======================================= HOT is a new template format meant to replace the Heat CloudFormation-compatible format (CFN) as the native format supported by the Heat over time. This guide is targeted towards template authors and explains how to write HOT templates based on examples. A detailed specification of HOT can be found at :ref:`hot_spec`. ------ Status ------ HOT support is still under development and needs more work to provide access to all functionality currently available via the CFN compatible template interface. This guide will be updated periodically whenever new features get implemented for HOT. ---------------------------------- Writing a hello world HOT template ---------------------------------- This section gives an introduction on how to write HOT templates, starting from very basic steps and then going into more and more detail by means of examples. A most basic template --------------------- The most basic template you can think of may contain only a single resource definition using only predefined properties (along with the mandatory Heat template version tag). For example, the template below could be used to simply deploy a single compute instance. :: heat_template_version: 2013-05-23 description: Simple template to deploy a single compute instance resources: my_instance: type: OS::Nova::Server properties: key_name: my_key image: F18-x86_64-cfntools flavor: m1.small Each HOT template has to include the *heat_template_version* key with value '2013-05-23' (the current version of HOT). While the *description* is optional, it is good practice to include some useful text that describes what users can do with the template. In case you want to provide a longer description that does not fit on a single line, you can provide multi-line text in YAML, for example: :: description: > This is how you can provide a longer description of your template that goes over several lines. The *resources* section is required and must contain at least one resource definition. In the example above, a compute instance is defined with fixed values for the 'key_name', 'image' and 'flavor' parameters. Note that all those elements, i.e. a key-pair with the given name, the image and the flavor have to exist in the OpenStack environment where the template is used. Typically a template is made more easily reusable, though, by defining a set of *input parameters* instead of hard-coding such values. Template input parameters ------------------------- Input parameters defined in the *parameters* section of a HOT template (see also :ref:`hot_spec_parameters`) allow users to customize a template during deployment. For example, this allows for providing custom key-pair names or image IDs to be used for a deployment. From a template author's perspective, this helps to make a template more easily reusable by avoiding hardcoded assumptions. Sticking to the example used above, it makes sense to allow users to provide their custom key-pairs, provide their own image, and to select a flavor for the compute instance. This can be achieved by extending the initial template as follows: :: heat_template_version: 2013-05-23 description: Simple template to deploy a single compute instance parameters: key_name: type: string label: Key Name description: Name of key-pair to be used for compute instance image_id: type: string label: Image ID description: Image to be used for compute instance instance_type: type: string label: Instance Type description: Type of instance (flavor) to be used resources: my_instance: type: OS::Nova::Server properties: key_name: { get_param: key_name } image: { get_param: image_id } flavor: { get_param: instance_type } In the example above, three input parameters have been defined that have to be provided by the user upon deployment. The fixed values for the respective resource properties have been replaced by references to the corresponding input parameters by means of the *get_param* function (see also :ref:`hot_spec_intrinsic_functions`). You can also define default values for input parameters which will be used in case the user does not provide the respective parameter during deployment. For example, the following definition for the *instance_type* parameter would select the 'm1.small' flavor unless specified otherwise be the user. :: parameters: instance_type: type: string label: Instance Type description: Type of instance (flavor) to be used default: m1.small Another option that can be specified for a parameter is to hide its value when users request information about a stack deployed from a template. This is achieved by the *hidden* attribute and useful, for example when requesting passwords as user input: :: parameters: database_password: type: string label: Database Password description: Password to be used for database hidden: true Restricting user input ~~~~~~~~~~~~~~~~~~~~~~ In some cases you might want to restrict the values of input parameters that users can supply. For example, you might know that the software running in a compute instance needs a certain amount of resources so you might want to restrict the *instance_type* parameter introduced above. Parameters in HOT templates can be restricted by adding a *constraints* section (see also :ref:`hot_spec_parameters_constraints`). For example, the following would allow only three values to be provided as input for the *instance_type* parameter: :: parameters: instance_type: type: string label: Instance Type description: Type of instance (flavor) to be used constraints: - allow_values: [ m1.medium, m1.large, m1.xlarge ] description: Value must be one of m1.medium, m1.large or m1.xlarge. The *constraints* section allows for defining a list of constraints that must all be fulfilled by user input. For example, the following list of constraints could be used to clearly specify format requirements on a password to be provided by users: :: parameters: database_password: type: string label: Database Password description: Password to be used for database hidden: true constraints: - length: { min: 6, max: 8 } description: Password length must be between 6 and 8 characters. - allowed_pattern: "[a-zA-Z0-9]+" description: Password must consist of characters and numbers only. - allowed_pattern: "[A-Z]+[a-zA-Z0-9]*" description: Password must start with an uppercase character. Note that you can define multiple constraints of the same type. Especially in the case of allowed patterns this not only allows for keeping regular expressions simple and maintainable, but also for keeping error messages to be presented to users precise. Providing template outputs -------------------------- In addition to template customization through input parameters, you will typically want to provide outputs to users, which can be done in the *outputs* section of a template (see also :ref:`hot_spec_outputs`). For example, the IP address by which the instance defined in the example above can be accessed should be provided to users. Otherwise, users would have to look it up themselves. The definition for providing the IP address of the compute instance as an output is shown in the following snippet: :: outputs: instance_ip: description: The IP address of the deployed instance value: { get_attr: [my_instance, first_address] } Output values are typically resolved using intrinsic function such as the *get_attr* function in the example above (see also :ref:`hot_spec_intrinsic_functions`). heat-2014.1/doc/source/template_guide/index.rst0000664000175400017540000000132712323734123022561 0ustar jenkinsjenkins00000000000000.. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Template Guide ============== .. toctree:: :maxdepth: 2 environment functions openstack cfn contrib hot_guide hot_spec heat-2014.1/doc/source/template_guide/openstack.rst0000664000175400017540000000122112323734123023432 0ustar jenkinsjenkins00000000000000.. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. OpenStack Resource Types ------------------------ .. resourcepages:: OS:: heat-2014.1/doc/source/template_guide/hot_spec.rst0000664000175400017540000006062012323734126023262 0ustar jenkinsjenkins00000000000000.. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. .. _hot_spec: =============================================== Heat Orchestration Template (HOT) Specification =============================================== HOT is a new template format meant to replace the Heat CloudFormation-compatible format (CFN) as the native format supported by the Heat over time. This specification explains in detail all elements of the HOT template format. An example driven guide to writing HOT templates can be found at :ref:`hot_guide`. ------ Status ------ HOT support is still under development and needs more work to provide access to all functionality currently available via the CFN compatible template interface. This specification will be updated periodically whenever new features get implemented for HOT. ------------------ Template Structure ------------------ HOT templates are defined in YAML and follow the structure outlined below. :: heat_template_version: 2013-05-23 description: # a description of the template parameter_groups: # a declaration of input parameter groups and order parameters: # declaration of input parameters resources: # declaration of template resources outputs: # declaration of output parameters heat_template_version This key with value *2013-05-23* (or a later date) indicates that the YAML document is a HOT template of the specified version. description This *optional* key allows for giving a description of the template, or the workload that can be deployed using the template. parameter_groups This section allows for specifying how the input parameters should be grouped and the order to provide the parameters in. This section is *optional* and can be omitted when necessary. parameters This section allows for specifying input parameters that have to be provided when instantiating the template. The section is *optional* and can be omitted when no input is required. resources This section contains the declaration of the single resources of the template. This section is mandatory and at least one resource must be defined in any HOT template. outputs This section allows for specifying output parameters available to users once the template has been instantiated. This section is *optional* and can be omitted when no output values are required. .. _hot_spec_parameter_groups: ------------------------ Parameter Groups Section ------------------------ The *parameter_groups* section allows for specifying how the input parameters should be grouped and the order to provide the parameters in. These groups are typically used to describe expected behavior for downstream user interfaces. These groups are specified in a list with each group containing a list of associated parameters. The lists are used to denote the expected order of the parameters. Each parameter should be associated to a specific group only once using the parameter name to bind it to a defined parameter in the parameters section. :: parameter_groups: - label: description: parameters: - - label A human-readable label that defines the associated group of parameters. description This attribute allows for giving a human-readable description of the parameter group. parameters A list of parameters associated with this parameter group. param name The name of the parameter that is defined in the associated parameters section. .. _hot_spec_parameters: ------------------ Parameters Section ------------------ The *parameters* section allows for specifying input parameters that have to be provided when instantiating the template. Such parameters are typically used to customize each deployment (e.g. by setting custom user names or passwords) or for binding to environment-specifics like certain images. Each parameter is specified in a separated nested block with the name of the parameters defined in the first line and additional attributes such as type or default value defined as nested elements. :: parameters: : type: label: description: default: hidden: constraints: param name The name of the parameter is defined at the top of each parameter block. type This attribute specifies the type of parameter. Currently supported types are *string*, *number*, *comma_delimited_list* or *json*. label This *optional* attribute allows for giving a human readable name of the parameter. description This *optional* attribute allows for giving a human readable description of the parameter. default This *optional* attribute allows for defining a default value for the parameters which will be used in case the parameter is not specified by the user during deployment. hidden This *optional* attribute allows for specifying whether the parameters should be hidden when showing information about a stack created from the template at runtime (e.g. for hiding passwords that were specified as parameters). If not specified, the default value 'false' will be used. constraints This *optional* block allows for specifying additional constraints on the parameter, such as minimum or maximum values for numeric parameters. The following example shows a minimalistic definition of two parameters. Note that the description and label are actually optional, but is good practice to provide a useful description and label for each parameter. :: parameters: user_name: type: string label: User Name description: User name to be configured for the application port_number: type: number label: Port Number description: Port number to be configured for the web server .. _hot_spec_parameters_constraints: Parameter Constraints --------------------- The *constraints* block of a parameter definition allows for defining additional validation constraints that apply to the value of the parameter. At instantiation time of the template, user provided parameter values are validated against those constraints to make sure the provided values match expectations of the template author. Constraints are defined in the form of a bulleted list according to the following syntax: :: constraints: - : description: constraint type The constraint type specifies the kind of constraint defined in the current bulleted list item. The set of currently supported constraints is given below. constraint definition This value defines the actual constraint, depending on the constraint type. The concrete syntax for each constraint type is given below. description This *optional* attribute allows for specifying a concrete description of the current constraint. This text will be presented to the user, for example, when the provided input value for a parameter violates the constraint. If omitted, a default validation message will be presented to the user. The following example show the definition of a string parameter with two constraints. Note that while the descriptions for each constraint are optional, it is good practice to provide concrete descriptions so useful messages can be presented to the user at deployment time. :: parameters: user_name: type: string label: User Name description: User name to be configured for the application constraints: - length: { min: 6, max: 8 } description: User name must be between 6 and 8 characters - allowed_pattern: "[A-Z]+[a-zA-Z0-9]*" description: User name must start with an uppercase character The following sections list the supported types of parameter constraints, along with the concrete syntax for each type. length ~~~~~~ The *length* constraint applies to parameters of type *string* and allows for defining a lower and upper limit for the length of the string value. The syntax for the length constraint is: :: length: { min: , max: } It is possible to define a length constraint with only a lower limit or an upper limit. However, at least one of *min* or *max* must be specified. range ~~~~~ The *range* constraint applies to parameters of type *number* and allows for defining a lower and upper limit for the numeric value of the parameter. The syntax of the range constraint is: :: range: { min: , max: } It is possible to define a range constraint with only a lower limit or an upper limit. However, at least one of *min* or *max* must be specified. The minimum or maximum boundaries are included in the range. For example, the following range constraint would allow for all numeric values between 0 and 10. :: range: { min: 0, max: 10 } allowed_values ~~~~~~~~~~~~~~ The *allowed_values* constraint applies to parameters of type string or number and allows for specifying a set of possible values for a parameter. At deployment time, the user provided value for the respective parameter must match one of the elements of the specified list. The syntax of the allowed_values constraint is: :: allowed_values: [ , , ... ] Alternatively, the YAML bulleted list notation can be used: :: allowed_values: - - - ... For example: :: parameters: instance_type: type: string label: Instance Type description: Instance type for compute instances constraints: - allowed_values: - m1.small - m1.medium - m1.large allowed_pattern ~~~~~~~~~~~~~~~ The *allowed_pattern* constraint applies to parameters of type string and allows for specifying a regular expression against which a user provided parameter value must evaluate at deployment. The syntax of the allowed_pattern constraint is: :: allowed_pattern: For example: :: parameters: user_name: type: string label: User Name description: User name to be configured for the application constraints: - allowed_pattern: "[A-Z]+[a-zA-Z0-9]*" description: User name must start with an uppercase character custom_constraint ~~~~~~~~~~~~~~~~~ The *custom_constraint* constraint adds an extra step of validation, generally to check that the specified resource exists in the backend. Custom constraints get implemented by plug-ins and can provide any kind of advanced constraint validation logic. The syntax of the custom_constraint constraint is: :: custom_constraint: The *name* specifies the concrete type of custom constraint. It corresponds to the name under which the respective validation plugin has been registered with the Heat engine. For example: :: parameters: key_name type: string description: SSH key pair constraints: - custom_constraint: nova.keypair .. _hot_spec_resources: ----------------- Resources Section ----------------- In the *resources* section, the templates for actual resources that will make up a stack deployed from the HOT template (e.g. compute instances, networks, storage volumes) are defined. Each resource is defined as a separate block in the resources section according to the syntax below. :: resources: : type: properties: : metadata: depends_on: update_policy: deletion_policy: resource ID A resource block is headed by the resource ID, which must be unique within the resource section of a template. type This attribute specifies the type of resource, such as OS::Nova::Server. properties This *optional* section contains a list of resource specific properties. The property value can be provided in place, or can be provided via a function (see :ref:`hot_spec_intrinsic_functions`). metadata This *optional* section contains resource type specific metadata. depends_on This *optional* attribute allows for specifying dependencies of the current resource on one or more other resources. Please refer to section :ref:`hot_spec_resources_dependencies` for details. update_policy: This *optional* attribute allows for specifying an update policy for the resource in the form of a nested dictionary (name-value pairs). Whether update policies are supported and what the exact semantics are depends on the type of the current resource. deletion_policy: This *optional* attribute allows for specifying a deletion policy for the resource (one of the values Delete, Retain or Snapshot). Which type of deletion policy is supported depends on the type of the current resource. Depending on the type of resource, the resource block might include more resource specific data. Basically all resource types that can be used in CFN templates can also be used in HOT templates, adapted to the YAML structure as outlined above. Below is an example of a simple compute resource definition with some fixed property values. :: resources: my_instance: type: OS::Nova::Server properties: flavor: m1.small image: F18-x86_64-cfntools .. _hot_spec_resources_dependencies: Resource Dependencies --------------------- By means of the *depends_on* attribute within a resource section it is possible to define a dependency between a resource and one or more other resources. If a resource depends on just one other resource, the ID of the other resource is specified as value of the *depends_on* attribute as shown in the following example. :: resources: server1: type: OS::Nova::Server depends_on: server2 server2: type: OS::Nova::Server If a resource depends on more than one other resource, the value of the *depends_on* attribute is specified as a list of resource IDs as shown in the following example: :: resources: server1: type: OS::Nova::Server depends_on: [ server2, server3 ] server2: type: OS::Nova::Server server3: type: OS::Nova::Server .. _hot_spec_outputs: --------------- Outputs Section --------------- In the *outputs* section, any output parameters that should be available to the user can be defined. Typically, this would be, for example, parameters such as IP addresses of deployed instances, or URLs of web applications deployed as part of a stack. Each output parameter is defined as a separate block within the outputs section according to the following syntax: :: outputs: : description: value: parameter name An output parameter block is headed by the output parameter name, which must be unique within the outputs section of a template. description This element gives a short description of the output parameter. parameter value This element specifies the value of the output parameter. Typically, this will be resolved by means of a function, e.g. by getting an attribute value of one of the stack's resources (see also :ref:`hot_spec_intrinsic_functions`). The example below shows, how the IP address of a compute resource can be defined as an output parameter. :: outputs: instance_ip: description: IP address of the deployed compute instance value: { get_attr: [my_instance, first_address] } .. _hot_spec_intrinsic_functions: ------------------- Intrinsic Functions ------------------- HOT provides a set of intrinsic functions that can be used inside HOT templates to perform specific tasks, such as getting the value of a resource attribute at runtime. A definition of all intrinsic functions available in HOT is given below. get_param --------- The *get_param* function allows for referencing an input parameter of a template from anywhere within a template. At runtime, it will be resolved to the value provided for this input parameter. The syntax of the get_param function is as follows: :: get_param: - - (optional) - (optional) - ... parameter name The parameter name is required as it specifies the parameter to be resolved. If the parameter returns a complex data structure such as a list or a map, then subsequent keys or indexes can be specified which navigate the data structure to return the desired value. A sample use of this function in context of a resource definition is shown below. :: parameters: instance_type: type: string label: Instance Type description: Instance type to be used. server_data: type: json resources: my_instance: type: OS::Nova::Server properties: flavor: { get_param: instance_type} metadata: { get_param: [ server_data, metadata ] } key_name: { get_param: [ server_data, keys, 0 ] } In this example, if the instance_type/server_data parameters contained the following data: :: {"instance_type": "m1.tiny", {"server_data": {"metadata": {"foo": "bar"}, "keys": ["a_key","other_key"]}}} then the value of the property 'flavor' would resolve to "m1.tiny", 'metadata' would resolve to {"foo": "bar"} and 'key_name' would resolve to "a_key". get_attr -------- The *get_attr* function allows referencing an attribute of a resource. At runtime, it will be resolved to the value of an attribute of a resource instance created from the respective resource definition of the template. The syntax of the get_attr function is as follows: :: get_attr: - - - (optional) - (optional) - ... resource ID This parameter specifies the resource for which the attributes shall be resolved. This resource must be defined within the *resources* section of the template (see also :ref:`hot_spec_resources`). attribute name The attribute name is required as it specifies the attribute to be resolved. If the attribute returns a complex data structure such as a list or a map, then subsequent keys or indexes can be specified which navigate the data structure to return the desired value. Some examples of how to use the get_attr function are shown below: :: resources: my_instance: type: OS::Nova::Server # ... outputs: instance_ip: description: IP address of the deployed compute instance value: { get_attr: [my_instance, first_address] } instance_private_ip: description: Private IP address of the deployed compute instance value: { get_attr: [my_instance, networks, private, 0] } In this example, if the networks attribute contained the following data: :: {"public": ["2001:0db8:0000:0000:0000:ff00:0042:8329", "1.2.3.4"], "private": ["10.0.0.1"]} then the value of the get_attr function would resolve to "10.0.0.1". get_resource ------------ The *get_resource* function allows for referencing another resource within the same template. At runtime, it will be resolved to reference ID of the resource, which is resource type specific. For example, a reference to a floating IP resource will return the respective IP address at runtime. The syntax of the get_resource function is as follows: :: get_resource: The *resource ID* of the referenced resources as used in the current template is given as single parameter to the get_resource function. str_replace ----------- The *str_replace* function allows for dynamically constructing strings by providing a template string with placeholders and a list of mappings to assign values to those placeholders at runtime. The placeholders are replaced with mapping values wherever a mapping key exactly matches a placeholder. The syntax of the str_replace function is as follows: :: str_replace: template: